Swigging the Zoom Headers
---[ typemaps ]--------------------------------------------------------------
::: scope 0

Hash {
    'jdouble' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jdouble, 
            'code' : double, 
            'type' : jdouble, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : D, 
            }
, 
            'typemap' : typemap(directorin) jdouble, 
            'code' : $input = $1;, 
            'type' : jdouble, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jdouble, 
            'code' : $jniinput, 
            'type' : jdouble, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jdouble, 
            'code' :  $1 = $input; , 
            'type' : jdouble, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jdouble, 
            'code' :  $result = $input; , 
            'type' : jdouble, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jdouble, 
            'code' : $javacall, 
            'type' : jdouble, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jdouble, 
            'code' : jdouble, 
            'type' : jdouble, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jdouble, 
            'code' : double, 
            'type' : jdouble, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jdouble, 
            'code' :  $result = $1; , 
            'type' : jdouble, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 90, 
            }
, 
            'typemap' : typemap(typecheck) jdouble, 
            'code' : , 
            'type' : jdouble, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jdouble, 
            'code' : $javainput, 
            'type' : jdouble, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jdouble, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jdouble, 
        }
, 
    }
, 
    'r.q(const).double' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) double const &, 
            'code' : double, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : D, 
            }
, 
            'typemap' : typemap(directorin) double const &, 
            'code' : $input = (jdouble)$1_name;, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) double const &, 
            'code' : $jniinput, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) double const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).double, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) double const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).double, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) double const &, 
            'code' : $javacall, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) double const &, 
            'code' : jdouble, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) double const &, 
            'code' : double, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) double const &, 
            'code' :  $result = (jdouble)*$1; , 
            'type' : r.q(const).double, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 90, 
            }
, 
            'typemap' : typemap(typecheck) double const &, 
            'code' : , 
            'type' : r.q(const).double, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) double const &, 
            'code' : $javainput, 
            'type' : r.q(const).double, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) double const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).double, 
        }
, 
    }
, 
    'double' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) double, 
            'code' : double, 
            'type' : double, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : D, 
            }
, 
            'typemap' : typemap(directorin) double, 
            'code' : $input = (jdouble) $1;, 
            'type' : double, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) double, 
            'code' : $jniinput, 
            'type' : double, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) double, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : double, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) double, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : double, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) double, 
            'code' : $javacall, 
            'type' : double, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) double, 
            'code' : jdouble, 
            'type' : double, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) double, 
            'code' : double, 
            'type' : double, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) double, 
            'code' :  $result = (jdouble)$1; , 
            'type' : double, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 90, 
            }
, 
            'typemap' : typemap(typecheck) double, 
            'code' : , 
            'type' : double, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) double, 
            'code' : $javainput, 
            'type' : double, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) double, 
            'code' : {
    return $jnicall;
  }, 
            'type' : double, 
        }
, 
    }
, 
    'p.double' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) double *INOUT, 
                'code' : , 
                'type' : p.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) double *INOUT, 
                'code' : double[], 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) double *INOUT, 
                'code' : $jniinput, 
                'type' : p.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Double;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide double *INOUT directorin typemap, double array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) double *INOUT, 
                'code' : {
}, 
                'type' : p.double, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) double *INOUT, 
                'code' : { jenv->ReleaseDoubleArrayElements($input, (jdouble *)$1, 0); }, 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) double *INOUT, 
                'code' : $javacall, 
                'type' : p.double, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) double *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetDoubleArrayElements($input, 0); 
}, 
                'type' : p.double, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide double *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) double *INOUT, 
                'code' : {
}, 
                'type' : p.double, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1090, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) double *INOUT, 
                'code' : , 
                'type' : p.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) double *INOUT, 
                'code' : jdoubleArray, 
                'type' : p.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) double *INOUT, 
                'code' : double[], 
                'type' : p.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) double *INOUT, 
                'code' : $javainput, 
                'type' : p.double, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) double *INPUT, 
                'code' : , 
                'type' : p.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) double *INPUT, 
                'code' : double, 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) double *INPUT, 
                'code' : $jniinput, 
                'type' : p.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : D, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) double *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jdouble *) $1; , 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) double *INPUT, 
                'code' : $javacall, 
                'type' : p.double, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) double *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.double, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) double *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) double *INPUT, 
                'code' : jdouble, 
                'type' : p.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) double *INPUT, 
                'code' : double, 
                'type' : p.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) double *INPUT, 
                'code' : $javainput, 
                'type' : p.double, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 90, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) double *INPUT, 
                'code' : , 
                'type' : p.double, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) double *OUTPUT, 
                'code' : , 
                'type' : p.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) double *OUTPUT, 
                'code' : double[], 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) double *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Double;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide double *OUTPUT directorin typemap, double array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) double *OUTPUT, 
                'code' : {
}, 
                'type' : p.double, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) double *OUTPUT, 
                'code' : {
  jdouble jvalue = (jdouble)temp$argnum;
  jenv->SetDoubleArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) double *OUTPUT, 
                'code' : $javacall, 
                'type' : p.double, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) double *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.double, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide double *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) double *OUTPUT, 
                'code' : {
}, 
                'type' : p.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) double *OUTPUT, 
                'code' : jdoubleArray, 
                'type' : p.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) double *OUTPUT, 
                'code' : double[], 
                'type' : p.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) double *OUTPUT, 
                'code' : $javainput, 
                'type' : p.double, 
            }
, 
        }
, 
    }
, 
    'r.double' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) double &INOUT, 
                'code' : , 
                'type' : r.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) double &INOUT, 
                'code' : double[], 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) double &INOUT, 
                'code' : $jniinput, 
                'type' : r.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Double;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide double *INOUT directorin typemap, double array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) double &INOUT, 
                'code' : {
}, 
                'type' : r.double, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) double &INOUT, 
                'code' : { jenv->ReleaseDoubleArrayElements($input, (jdouble *)$1, 0); }, 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) double &INOUT, 
                'code' : $javacall, 
                'type' : r.double, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) double &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetDoubleArrayElements($input, 0); 
}, 
                'type' : r.double, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide double *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) double &INOUT, 
                'code' : {
}, 
                'type' : r.double, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1090, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) double &INOUT, 
                'code' : , 
                'type' : r.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) double &INOUT, 
                'code' : jdoubleArray, 
                'type' : r.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) double &INOUT, 
                'code' : double[], 
                'type' : r.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) double &INOUT, 
                'code' : $javainput, 
                'type' : r.double, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) double &INPUT, 
                'code' : , 
                'type' : r.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) double &INPUT, 
                'code' : double, 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) double &INPUT, 
                'code' : $jniinput, 
                'type' : r.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : D, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) double &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jdouble *) &$1; , 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) double &INPUT, 
                'code' : $javacall, 
                'type' : r.double, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) double &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.double, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) double &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) double &INPUT, 
                'code' : jdouble, 
                'type' : r.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) double &INPUT, 
                'code' : double, 
                'type' : r.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) double &INPUT, 
                'code' : $javainput, 
                'type' : r.double, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 90, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) double &INPUT, 
                'code' : , 
                'type' : r.double, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) double &OUTPUT, 
                'code' : , 
                'type' : r.double, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) double &OUTPUT, 
                'code' : double[], 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) double &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.double, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Double;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) double &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.double, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) double &OUTPUT, 
                'code' : {
  jdouble jvalue = (jdouble)temp$argnum;
  jenv->SetDoubleArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.double, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) double &OUTPUT, 
                'code' : $javacall, 
                'type' : r.double, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) double &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.double, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide double *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) double &OUTPUT, 
                'code' : {
}, 
                'type' : r.double, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) double &OUTPUT, 
                'code' : jdoubleArray, 
                'type' : r.double, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) double &OUTPUT, 
                'code' : double[], 
                'type' : r.double, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) double &OUTPUT, 
                'code' : $javainput, 
                'type' : r.double, 
            }
, 
        }
, 
    }
, 
    'a(ANY).double' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) double [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).double, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) double [ANY], 
            'code' : double[], 
            'type' : a(ANY).double, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) double [ANY], 
            'code' :  SWIG_JavaArrayArgoutDouble(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).double, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jdouble, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) double [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInDouble(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).double, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) double [ANY], 
            'code' : jdoubleArray, 
            'type' : a(ANY).double, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) double [ANY], 
            'code' : double[], 
            'type' : a(ANY).double, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) double [ANY], 
            'code' : $result = SWIG_JavaArrayOutDouble(jenv, $1, $1_dim0); , 
            'type' : a(ANY).double, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) double [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).double, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1090, 
            }
, 
            'typemap' : typemap(typecheck) double [ANY], 
            'code' : , 
            'type' : a(ANY).double, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) double [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).double, 
        }
, 
    }
, 
    'a().double' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) double [], 
            'code' :  delete [] $1; , 
            'type' : a().double, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) double [], 
            'code' : double[], 
            'type' : a().double, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) double [], 
            'code' :  SWIG_JavaArrayArgoutDouble(jenv, jarr$argnum, $1, $input); , 
            'type' : a().double, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jdouble, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) double [], 
            'code' :   if (!SWIG_JavaArrayInDouble(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().double, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) double [], 
            'code' : jdoubleArray, 
            'type' : a().double, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) double [], 
            'code' : double[], 
            'type' : a().double, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) double [], 
            'code' : $result = SWIG_JavaArrayOutDouble(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().double, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) double [], 
            'code' : $javainput, 
            'type' : a().double, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1090, 
            }
, 
            'typemap' : typemap(typecheck) double [], 
            'code' : , 
            'type' : a().double, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) double [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().double, 
        }
, 
    }
, 
    'bool' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) bool, 
            'code' : boolean, 
            'type' : bool, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) bool, 
            'code' : $jniinput, 
            'type' : bool, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Z, 
            }
, 
            'typemap' : typemap(directorin) bool, 
            'code' : $input = (jboolean) $1;, 
            'type' : bool, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) bool, 
            'code' :  $1 = $input ? true : false; , 
            'type' : bool, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) bool, 
            'code' :  $result = $input ? true : false; , 
            'type' : bool, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) bool, 
            'code' : $javacall, 
            'type' : bool, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) bool, 
            'code' : jboolean, 
            'type' : bool, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) bool, 
            'code' : boolean, 
            'type' : bool, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) bool, 
            'code' :  $result = (jboolean)$1; , 
            'type' : bool, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 15, 
            }
, 
            'typemap' : typemap(typecheck) bool, 
            'code' : , 
            'type' : bool, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) bool, 
            'code' : $javainput, 
            'type' : bool, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) bool, 
            'code' : {
    return $jnicall;
  }, 
            'type' : bool, 
        }
, 
    }
, 
    'jfloat' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jfloat, 
            'code' : float, 
            'type' : jfloat, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : F, 
            }
, 
            'typemap' : typemap(directorin) jfloat, 
            'code' : $input = $1;, 
            'type' : jfloat, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jfloat, 
            'code' : $jniinput, 
            'type' : jfloat, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jfloat, 
            'code' :  $1 = $input; , 
            'type' : jfloat, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jfloat, 
            'code' :  $result = $input; , 
            'type' : jfloat, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jfloat, 
            'code' : $javacall, 
            'type' : jfloat, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jfloat, 
            'code' : jfloat, 
            'type' : jfloat, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jfloat, 
            'code' : float, 
            'type' : jfloat, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jfloat, 
            'code' :  $result = $1; , 
            'type' : jfloat, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 80, 
            }
, 
            'typemap' : typemap(typecheck) jfloat, 
            'code' : , 
            'type' : jfloat, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jfloat, 
            'code' : $javainput, 
            'type' : jfloat, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jfloat, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jfloat, 
        }
, 
    }
, 
    'int' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) int, 
            'code' : int, 
            'type' : int, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) int, 
            'code' : $input = (jint) $1;, 
            'type' : int, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) int, 
            'code' : $jniinput, 
            'type' : int, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) int, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : int, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) int, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : int, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) int, 
            'code' : $javacall, 
            'type' : int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) int, 
            'code' : jint, 
            'type' : int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) int, 
            'code' : int, 
            'type' : int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) int, 
            'code' :  $result = (jint)$1; , 
            'type' : int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) int, 
            'code' : , 
            'type' : int, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) int, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) int, 
            'code' : $javainput, 
            'type' : int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) int, 
            'code' : {
    return $jnicall;
  }, 
            'type' : int, 
        }
, 
    }
, 
    'a(ANY).bool' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) bool [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) bool [ANY], 
            'code' : boolean[], 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) bool [ANY], 
            'code' :  SWIG_JavaArrayArgoutBool(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jboolean, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) bool [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInBool(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) bool [ANY], 
            'code' : jbooleanArray, 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) bool [ANY], 
            'code' : boolean[], 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) bool [ANY], 
            'code' : $result = SWIG_JavaArrayOutBool(jenv, $1, $1_dim0); , 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) bool [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1015, 
            }
, 
            'typemap' : typemap(typecheck) bool [ANY], 
            'code' : , 
            'type' : a(ANY).bool, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) bool [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).bool, 
        }
, 
    }
, 
    'r.q(const).long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long const &, 
            'code' : int, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) long const &, 
            'code' : $input = (jint)$1_name;, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) long const &, 
            'code' : $jniinput, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).long, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) long const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) long const &, 
            'code' : $javacall, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long const &, 
            'code' : jint, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long const &, 
            'code' : int, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long const &, 
            'code' :  $result = (jint)*$1; , 
            'type' : r.q(const).long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) long const &, 
            'code' : , 
            'type' : r.q(const).long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long const &, 
            'code' : $javainput, 
            'type' : r.q(const).long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).long, 
        }
, 
    }
, 
    'a().long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) long [], 
            'code' :  delete [] $1; , 
            'type' : a().long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long [], 
            'code' : int[], 
            'type' : a().long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) long [], 
            'code' :  SWIG_JavaArrayArgoutLong(jenv, jarr$argnum, $1, $input); , 
            'type' : a().long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long [], 
            'code' :   if (!SWIG_JavaArrayInLong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long [], 
            'code' : jintArray, 
            'type' : a().long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long [], 
            'code' : int[], 
            'type' : a().long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long [], 
            'code' : $result = SWIG_JavaArrayOutLong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long [], 
            'code' : $javainput, 
            'type' : a().long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) long [], 
            'code' : , 
            'type' : a().long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().long, 
        }
, 
    }
, 
    'r.int' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) int &INOUT, 
                'code' : , 
                'type' : r.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) int &INOUT, 
                'code' : int[], 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) int &INOUT, 
                'code' : $jniinput, 
                'type' : r.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide int *INOUT directorin typemap, int array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) int &INOUT, 
                'code' : {
}, 
                'type' : r.int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) int &INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) int &INOUT, 
                'code' : $javacall, 
                'type' : r.int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) int &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : r.int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide int *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) int &INOUT, 
                'code' : {
}, 
                'type' : r.int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) int &INOUT, 
                'code' : , 
                'type' : r.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) int &INOUT, 
                'code' : jintArray, 
                'type' : r.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) int &INOUT, 
                'code' : int[], 
                'type' : r.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) int &INOUT, 
                'code' : $javainput, 
                'type' : r.int, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) int &INPUT, 
                'code' : , 
                'type' : r.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) int &INPUT, 
                'code' : int, 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) int &INPUT, 
                'code' : $jniinput, 
                'type' : r.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) int &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) &$1; , 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) int &INPUT, 
                'code' : $javacall, 
                'type' : r.int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) int &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.int, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) int &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) int &INPUT, 
                'code' : jint, 
                'type' : r.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) int &INPUT, 
                'code' : int, 
                'type' : r.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) int &INPUT, 
                'code' : $javainput, 
                'type' : r.int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) int &INPUT, 
                'code' : , 
                'type' : r.int, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) int &OUTPUT, 
                'code' : , 
                'type' : r.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) int &OUTPUT, 
                'code' : int[], 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) int &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) int &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) int &OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) int &OUTPUT, 
                'code' : $javacall, 
                'type' : r.int, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) int &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide int *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) int &OUTPUT, 
                'code' : {
}, 
                'type' : r.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) int &OUTPUT, 
                'code' : jintArray, 
                'type' : r.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) int &OUTPUT, 
                'code' : int[], 
                'type' : r.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) int &OUTPUT, 
                'code' : $javainput, 
                'type' : r.int, 
            }
, 
        }
, 
    }
, 
    'short' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) short, 
            'code' : short, 
            'type' : short, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : S, 
            }
, 
            'typemap' : typemap(directorin) short, 
            'code' : $input = (jshort) $1;, 
            'type' : short, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) short, 
            'code' : $jniinput, 
            'type' : short, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) short, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : short, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) short, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : short, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) short, 
            'code' : $javacall, 
            'type' : short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) short, 
            'code' : jshort, 
            'type' : short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) short, 
            'code' : short, 
            'type' : short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) short, 
            'code' :  $result = (jshort)$1; , 
            'type' : short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 35, 
            }
, 
            'typemap' : typemap(typecheck) short, 
            'code' : , 
            'type' : short, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) short, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) short, 
            'code' : $javainput, 
            'type' : short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) short, 
            'code' : {
    return $jnicall;
  }, 
            'type' : short, 
        }
, 
    }
, 
    'r.q(const).char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) char const &, 
            'code' : char, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : C, 
            }
, 
            'typemap' : typemap(directorin) char const &, 
            'code' : $input = (jchar)$1_name;, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) char const &, 
            'code' : $jniinput, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) char const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) char const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) char const &, 
            'code' : $javacall, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) char const &, 
            'code' : jchar, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) char const &, 
            'code' : char, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) char const &, 
            'code' :  $result = (jchar)*$1; , 
            'type' : r.q(const).char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 130, 
            }
, 
            'typemap' : typemap(typecheck) char const &, 
            'code' : , 
            'type' : r.q(const).char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) char const &, 
            'code' : $javainput, 
            'type' : r.q(const).char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) char const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).char, 
        }
, 
    }
, 
    'a().char' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 140, 
            }
, 
            'typemap' : typemap(typecheck) char [], 
            'code' : , 
            'type' : a().char, 
        }
, 
        'tmap:memberin' : Hash {
            'typemap' : typemap(memberin) char [], 
            'code' : {
  if ($input) strcpy((char *)$1, (const char *)$input);
  else $1[0] = 0;
}, 
            'type' : a().char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) char [], 
            'code' : String, 
            'type' : a().char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) char [], 
            'code' : $jniinput, 
            'type' : a().char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/lang/String;, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(directorin) char [], 
            'code' : $input = 0;
  if ($1) {
    $input = jenv->NewStringUTF((const char *)$1);
    if (!$input) return $null;
  }, 
            'type' : a().char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) char [], 
            'code' : $javacall, 
            'type' : a().char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(directorout) char [], 
            'code' : $1 = 0;
  if ($input) {
    $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$result) return $null;
  }, 
            'type' : a().char, 
        }
, 
        'tmap:out' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(out) char [], 
            'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);, 
            'type' : a().char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) char [], 
            'code' : jstring, 
            'type' : a().char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) char [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().char, 
        }
, 
        'tmap:globalin' : Hash {
            'typemap' : typemap(globalin) char [], 
            'code' : {
  if ($input) strcpy((char *)$1, (const char *)$input);
  else $1[0] = 0;
}, 
            'type' : a().char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(in) char [], 
            'code' : $1 = 0;
  if ($input) {
    $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$1) return $null;
  }, 
            'type' : a().char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) char [], 
            'code' : $javainput, 
            'type' : a().char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) char [], 
            'code' : String, 
            'type' : a().char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) char [], 
            'code' : , 
            'type' : a().char, 
        }
, 
        'tmap:freearg' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(freearg) char [], 
            'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);, 
            'type' : a().char, 
        }
, 
    }
, 
    'p.q(const).char' : Hash {
        'tmap:memberin' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 451:Setting a const char * variable may leak memory., 
            }
, 
            'typemap' : typemap(memberin) char const *, 
            'code' : {
  if ($input) {
     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
     strcpy((char *)$1, (const char *)$input);
  } else {
     $1 = 0;
  }
}, 
            'type' : p.q(const).char, 
        }
, 
        'tmap:globalin' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 451:Setting a const char * variable may leak memory., 
            }
, 
            'typemap' : typemap(globalin) char const *, 
            'code' : {
  if ($input) {
     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
     strcpy((char *)$1, (const char *)$input);
  } else {
     $1 = 0;
  }
}, 
            'type' : p.q(const).char, 
        }
, 
    }
, 
    'void' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) void, 
            'code' : void, 
            'type' : void, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) void, 
            'code' : $jniinput, 
            'type' : void, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : V, 
            }
, 
            'typemap' : typemap(directorin) void, 
            'code' : , 
            'type' : void, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) void, 
            'code' : $javacall, 
            'type' : void, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) void, 
            'code' : void, 
            'type' : void, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) void, 
            'code' : void, 
            'type' : void, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) void, 
            'code' : , 
            'type' : void, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) void, 
            'code' : {
    $jnicall;
  }, 
            'type' : void, 
        }
, 
    }
, 
    'r.q(const).short' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) short const &, 
            'code' : short, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : S, 
            }
, 
            'typemap' : typemap(directorin) short const &, 
            'code' : $input = (jshort)$1_name;, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) short const &, 
            'code' : $jniinput, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) short const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).short, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) short const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).short, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) short const &, 
            'code' : $javacall, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) short const &, 
            'code' : jshort, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) short const &, 
            'code' : short, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) short const &, 
            'code' :  $result = (jshort)*$1; , 
            'type' : r.q(const).short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 35, 
            }
, 
            'typemap' : typemap(typecheck) short const &, 
            'code' : , 
            'type' : r.q(const).short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) short const &, 
            'code' : $javainput, 
            'type' : r.q(const).short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) short const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).short, 
        }
, 
    }
, 
    'a(ANY).short' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) short [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).short, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) short [ANY], 
            'code' : short[], 
            'type' : a(ANY).short, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) short [ANY], 
            'code' :  SWIG_JavaArrayArgoutShort(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jshort, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) short [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInShort(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) short [ANY], 
            'code' : jshortArray, 
            'type' : a(ANY).short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) short [ANY], 
            'code' : short[], 
            'type' : a(ANY).short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) short [ANY], 
            'code' : $result = SWIG_JavaArrayOutShort(jenv, $1, $1_dim0); , 
            'type' : a(ANY).short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) short [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1035, 
            }
, 
            'typemap' : typemap(typecheck) short [ANY], 
            'code' : , 
            'type' : a(ANY).short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) short [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).short, 
        }
, 
    }
, 
    'a().short' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) short [], 
            'code' :  delete [] $1; , 
            'type' : a().short, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) short [], 
            'code' : short[], 
            'type' : a().short, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) short [], 
            'code' :  SWIG_JavaArrayArgoutShort(jenv, jarr$argnum, $1, $input); , 
            'type' : a().short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jshort, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) short [], 
            'code' :   if (!SWIG_JavaArrayInShort(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) short [], 
            'code' : jshortArray, 
            'type' : a().short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) short [], 
            'code' : short[], 
            'type' : a().short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) short [], 
            'code' : $result = SWIG_JavaArrayOutShort(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) short [], 
            'code' : $javainput, 
            'type' : a().short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1035, 
            }
, 
            'typemap' : typemap(typecheck) short [], 
            'code' : , 
            'type' : a().short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) short [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().short, 
        }
, 
    }
, 
    'long long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long long, 
            'code' : long, 
            'type' : long long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) long long, 
            'code' : $input = (jlong) $1;, 
            'type' : long long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) long long, 
            'code' : $jniinput, 
            'type' : long long, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long long, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : long long, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) long long, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : long long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) long long, 
            'code' : $javacall, 
            'type' : long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long long, 
            'code' : jlong, 
            'type' : long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long long, 
            'code' : long, 
            'type' : long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long long, 
            'code' :  $result = (jlong)$1; , 
            'type' : long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) long long, 
            'code' : , 
            'type' : long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long long, 
            'code' : $javainput, 
            'type' : long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long long, 
            'code' : {
    return $jnicall;
  }, 
            'type' : long long, 
        }
, 
    }
, 
    'r.q(const).long long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long long const &, 
            'code' : long, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) long long const &, 
            'code' : $input = (jlong)$1_name;, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) long long const &, 
            'code' : $jniinput, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long long const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) long long const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) long long const &, 
            'code' : $javacall, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long long const &, 
            'code' : jlong, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long long const &, 
            'code' : long, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long long const &, 
            'code' :  $result = (jlong)*$1; , 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) long long const &, 
            'code' : , 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long long const &, 
            'code' : $javainput, 
            'type' : r.q(const).long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long long const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).long long, 
        }
, 
    }
, 
    'unsigned long long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long long, 
            'code' : java.math.BigInteger, 
            'type' : unsigned long long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/math/BigInteger;, 
            }
, 
            'typemap' : typemap(directorin) unsigned long long, 
            'code' : {
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int swig_i;

  bae[0] = 0;
  for(swig_i=1; swig_i<9; swig_i++ ) {
    bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  $input = bigint;
}, 
            'type' : unsigned long long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned long long, 
            'code' : $jniinput, 
            'type' : unsigned long long, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long long, 
            'code' : { 
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  $1 = 0;
  for(i=0; i<sz; i++) {
    $1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
}, 
            'type' : unsigned long long, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) unsigned long long, 
            'code' : { 
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  $result = 0;
  for(i=0; i<sz; i++) {
    $result = ($result << 8) | ($1_type)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
}, 
            'type' : unsigned long long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned long long, 
            'code' : $javacall, 
            'type' : unsigned long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long long, 
            'code' : jobject, 
            'type' : unsigned long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long long, 
            'code' : java.math.BigInteger, 
            'type' : unsigned long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long long, 
            'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)($1>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  $result = bigint;
}, 
            'type' : unsigned long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 65, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long long, 
            'code' : , 
            'type' : unsigned long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long long, 
            'code' : $javainput, 
            'type' : unsigned long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long long, 
            'code' : {
    return $jnicall;
  }, 
            'type' : unsigned long long, 
        }
, 
    }
, 
    'r.q(const).unsigned long long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long long const &, 
            'code' : java.math.BigInteger, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/math/BigInteger;, 
            }
, 
            'typemap' : typemap(directorin) unsigned long long const &, 
            'code' : {
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int swig_i;

  bae[0] = 0;
  for(swig_i=1; swig_i<9; swig_i++ ) {
    bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  $input = bigint;
}, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned long long const &, 
            'code' : $jniinput, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long long const &, 
            'code' : { 
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  $1 = &temp;
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
}, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) unsigned long long const &, 
            'code' : { 
  static $*1_ltype temp;
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  $result = &temp;
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
}, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned long long const &, 
            'code' : $javacall, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long long const &, 
            'code' : jobject, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long long const &, 
            'code' : java.math.BigInteger, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long long const &, 
            'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)(*$1>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  $result = bigint;
}, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 65, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long long const &, 
            'code' : , 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long long const &, 
            'code' : $javainput, 
            'type' : r.q(const).unsigned long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long long const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).unsigned long long, 
        }
, 
    }
, 
    'jint' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jint, 
            'code' : int, 
            'type' : jint, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) jint, 
            'code' : $input = $1;, 
            'type' : jint, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jint, 
            'code' : $jniinput, 
            'type' : jint, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jint, 
            'code' :  $1 = $input; , 
            'type' : jint, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jint, 
            'code' :  $result = $input; , 
            'type' : jint, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jint, 
            'code' : $javacall, 
            'type' : jint, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jint, 
            'code' : jint, 
            'type' : jint, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jint, 
            'code' : int, 
            'type' : jint, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jint, 
            'code' :  $result = $1; , 
            'type' : jint, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) jint, 
            'code' : , 
            'type' : jint, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jint, 
            'code' : $javainput, 
            'type' : jint, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jint, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jint, 
        }
, 
    }
, 
    'p.long long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) long long *INOUT, 
                'code' : , 
                'type' : p.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) long long *INOUT, 
                'code' : long[], 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) long long *INOUT, 
                'code' : $jniinput, 
                'type' : p.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long long *INOUT directorin typemap, long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) long long *INOUT, 
                'code' : {
}, 
                'type' : p.long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) long long *INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) long long *INOUT, 
                'code' : $javacall, 
                'type' : p.long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) long long *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : p.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) long long *INOUT, 
                'code' : {
}, 
                'type' : p.long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) long long *INOUT, 
                'code' : , 
                'type' : p.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) long long *INOUT, 
                'code' : jlongArray, 
                'type' : p.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) long long *INOUT, 
                'code' : long[], 
                'type' : p.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) long long *INOUT, 
                'code' : $javainput, 
                'type' : p.long long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) long long *INPUT, 
                'code' : , 
                'type' : p.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) long long *INPUT, 
                'code' : long, 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) long long *INPUT, 
                'code' : $jniinput, 
                'type' : p.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) long long *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) $1; , 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) long long *INPUT, 
                'code' : $javacall, 
                'type' : p.long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) long long *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) long long *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) long long *INPUT, 
                'code' : jlong, 
                'type' : p.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) long long *INPUT, 
                'code' : long, 
                'type' : p.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) long long *INPUT, 
                'code' : $javainput, 
                'type' : p.long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) long long *INPUT, 
                'code' : , 
                'type' : p.long long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) long long *OUTPUT, 
                'code' : , 
                'type' : p.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) long long *OUTPUT, 
                'code' : long[], 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) long long *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long long *OUTPUT directorin typemap, long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) long long *OUTPUT, 
                'code' : {
}, 
                'type' : p.long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) long long *OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) long long *OUTPUT, 
                'code' : $javacall, 
                'type' : p.long long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) long long *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) long long *OUTPUT, 
                'code' : {
}, 
                'type' : p.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) long long *OUTPUT, 
                'code' : jlongArray, 
                'type' : p.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) long long *OUTPUT, 
                'code' : long[], 
                'type' : p.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) long long *OUTPUT, 
                'code' : $javainput, 
                'type' : p.long long, 
            }
, 
        }
, 
    }
, 
    'r.long long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) long long &INOUT, 
                'code' : , 
                'type' : r.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) long long &INOUT, 
                'code' : long[], 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) long long &INOUT, 
                'code' : $jniinput, 
                'type' : r.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long long *INOUT directorin typemap, long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) long long &INOUT, 
                'code' : {
}, 
                'type' : r.long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) long long &INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) long long &INOUT, 
                'code' : $javacall, 
                'type' : r.long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) long long &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : r.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) long long &INOUT, 
                'code' : {
}, 
                'type' : r.long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) long long &INOUT, 
                'code' : , 
                'type' : r.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) long long &INOUT, 
                'code' : jlongArray, 
                'type' : r.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) long long &INOUT, 
                'code' : long[], 
                'type' : r.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) long long &INOUT, 
                'code' : $javainput, 
                'type' : r.long long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) long long &INPUT, 
                'code' : , 
                'type' : r.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) long long &INPUT, 
                'code' : long, 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) long long &INPUT, 
                'code' : $jniinput, 
                'type' : r.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) long long &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) &$1; , 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) long long &INPUT, 
                'code' : $javacall, 
                'type' : r.long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) long long &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) long long &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) long long &INPUT, 
                'code' : jlong, 
                'type' : r.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) long long &INPUT, 
                'code' : long, 
                'type' : r.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) long long &INPUT, 
                'code' : $javainput, 
                'type' : r.long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) long long &INPUT, 
                'code' : , 
                'type' : r.long long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) long long &OUTPUT, 
                'code' : , 
                'type' : r.long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) long long &OUTPUT, 
                'code' : long[], 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) long long &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) long long &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) long long &OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) long long &OUTPUT, 
                'code' : $javacall, 
                'type' : r.long long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) long long &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) long long &OUTPUT, 
                'code' : {
}, 
                'type' : r.long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) long long &OUTPUT, 
                'code' : jlongArray, 
                'type' : r.long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) long long &OUTPUT, 
                'code' : long[], 
                'type' : r.long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) long long &OUTPUT, 
                'code' : $javainput, 
                'type' : r.long long, 
            }
, 
        }
, 
    }
, 
    'p.unsigned long long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned long long *INOUT, 
                'code' : , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned long long *INOUT, 
                'code' : java.math.BigInteger[], 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned long long *INOUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava.math.BigInteger;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long long *INOUT directorin typemap, unsigned long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned long long *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned long long *INOUT, 
                'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  jenv->SetObjectArrayElement($input, 0, bigint);
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned long long *INOUT, 
                'code' : $javacall, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned long long *INOUT, 
                'code' : { 
  jobject bigint;
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  bigint = jenv->GetObjectArrayElement($input, 0);
  if (!bigint) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
    return $null;
  }
  clazz = jenv->GetObjectClass(bigint);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod(bigint, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
  $1 = &temp;
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned long long *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1065, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned long long *INOUT, 
                'code' : , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned long long *INOUT, 
                'code' : jobjectArray, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned long long *INOUT, 
                'code' : java.math.BigInteger[], 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned long long *INOUT, 
                'code' : $javainput, 
                'type' : p.unsigned long long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned long long *INPUT, 
                'code' : , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned long long *INPUT, 
                'code' : java.math.BigInteger, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned long long *INPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : Ljava/math/BigInteger;, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned long long *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jobject *) $1; , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned long long *INPUT, 
                'code' : $javacall, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned long long *INPUT, 
                'code' : {
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
  $1 = &temp;
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned long long *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned long long *INPUT, 
                'code' : jobject, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned long long *INPUT, 
                'code' : java.math.BigInteger, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned long long *INPUT, 
                'code' : $javainput, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 65, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned long long *INPUT, 
                'code' : , 
                'type' : p.unsigned long long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned long long *OUTPUT, 
                'code' : , 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned long long *OUTPUT, 
                'code' : java.math.BigInteger[], 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned long long *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/BigInteger;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long long *OUTPUT directorin typemap, unsigned long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned long long *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned long long *OUTPUT, 
                'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  jenv->SetObjectArrayElement($input, 0, bigint);
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned long long *OUTPUT, 
                'code' : $javacall, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned long long *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned long long *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned long long *OUTPUT, 
                'code' : jobjectArray, 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned long long *OUTPUT, 
                'code' : java.math.BigInteger[], 
                'type' : p.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned long long *OUTPUT, 
                'code' : $javainput, 
                'type' : p.unsigned long long, 
            }
, 
        }
, 
    }
, 
    'r.unsigned long long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned long long &INOUT, 
                'code' : , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned long long &INOUT, 
                'code' : java.math.BigInteger[], 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned long long &INOUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava.math.BigInteger;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long long *INOUT directorin typemap, unsigned long long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned long long &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned long long &INOUT, 
                'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  jenv->SetObjectArrayElement($input, 0, bigint);
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned long long &INOUT, 
                'code' : $javacall, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned long long &INOUT, 
                'code' : { 
  jobject bigint;
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  bigint = jenv->GetObjectArrayElement($input, 0);
  if (!bigint) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
    return $null;
  }
  clazz = jenv->GetObjectClass(bigint);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod(bigint, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
  $1 = &temp;
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned long long &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1065, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned long long &INOUT, 
                'code' : , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned long long &INOUT, 
                'code' : jobjectArray, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned long long &INOUT, 
                'code' : java.math.BigInteger[], 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned long long &INOUT, 
                'code' : $javainput, 
                'type' : r.unsigned long long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned long long &INPUT, 
                'code' : , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned long long &INPUT, 
                'code' : java.math.BigInteger, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned long long &INPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : Ljava/math/BigInteger;, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned long long &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jobject *) &$1; , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned long long &INPUT, 
                'code' : $javacall, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned long long &INPUT, 
                'code' : {
  jclass clazz;
  jmethodID mid;
  jbyteArray ba;
  jbyte* bae;
  jsize sz;
  int i;

  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
    return $null;
  }
  clazz = jenv->GetObjectClass($input);
  mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
  ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
  bae = jenv->GetByteArrayElements(ba, 0);
  sz = jenv->GetArrayLength(ba);
  temp = 0;
  for(i=0; i<sz; i++) {
    temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
  }
  jenv->ReleaseByteArrayElements(ba, bae, 0);
  $1 = &temp;
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned long long &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned long long &INPUT, 
                'code' : jobject, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned long long &INPUT, 
                'code' : java.math.BigInteger, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned long long &INPUT, 
                'code' : $javainput, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 65, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned long long &INPUT, 
                'code' : , 
                'type' : r.unsigned long long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned long long &OUTPUT, 
                'code' : , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned long long &OUTPUT, 
                'code' : java.math.BigInteger[], 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned long long &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/BigInteger;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned long long &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned long long &OUTPUT, 
                'code' : { 
  jbyteArray ba = jenv->NewByteArray(9);
  jbyte* bae = jenv->GetByteArrayElements(ba, 0);
  jclass clazz = jenv->FindClass("java/math/BigInteger");
  jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
  jobject bigint;
  int i;

  bae[0] = 0;
  for(i=1; i<9; i++ ) {
    bae[i] = (jbyte)(temp$argnum>>8*(8-i));
  }

  jenv->ReleaseByteArrayElements(ba, bae, 0);
  bigint = jenv->NewObject(clazz, mid, ba);
  jenv->SetObjectArrayElement($input, 0, bigint);
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned long long &OUTPUT, 
                'code' : $javacall, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned long long &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned long long &OUTPUT, 
                'code' : {
}, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned long long &OUTPUT, 
                'code' : jobjectArray, 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned long long &OUTPUT, 
                'code' : java.math.BigInteger[], 
                'type' : r.unsigned long long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned long long &OUTPUT, 
                'code' : $javainput, 
                'type' : r.unsigned long long, 
            }
, 
        }
, 
    }
, 
    'a(ANY).long long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) long long [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long long [ANY], 
            'code' : long[], 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) long long [ANY], 
            'code' :  SWIG_JavaArrayArgoutLonglong(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long long [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInLonglong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long long [ANY], 
            'code' : jlongArray, 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long long [ANY], 
            'code' : long[], 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long long [ANY], 
            'code' : $result = SWIG_JavaArrayOutLonglong(jenv, $1, $1_dim0); , 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long long [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) long long [ANY], 
            'code' : , 
            'type' : a(ANY).long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long long [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).long long, 
        }
, 
    }
, 
    'a().long long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) long long [], 
            'code' :  delete [] $1; , 
            'type' : a().long long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long long [], 
            'code' : long[], 
            'type' : a().long long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) long long [], 
            'code' :  SWIG_JavaArrayArgoutLonglong(jenv, jarr$argnum, $1, $input); , 
            'type' : a().long long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long long [], 
            'code' :   if (!SWIG_JavaArrayInLonglong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().long long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long long [], 
            'code' : jlongArray, 
            'type' : a().long long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long long [], 
            'code' : long[], 
            'type' : a().long long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long long [], 
            'code' : $result = SWIG_JavaArrayOutLonglong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().long long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long long [], 
            'code' : $javainput, 
            'type' : a().long long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) long long [], 
            'code' : , 
            'type' : a().long long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long long [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().long long, 
        }
, 
    }
, 
    'a(ANY).unsigned long long' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1065, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long long [ANY], 
            'code' : , 
            'type' : a(ANY).unsigned long long, 
        }
, 
    }
, 
    'a().unsigned long long' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1065, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long long [], 
            'code' : , 
            'type' : a().unsigned long long, 
        }
, 
    }
, 
    'p.bool' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) bool *INOUT, 
                'code' : , 
                'type' : p.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) bool *INOUT, 
                'code' : boolean[], 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) bool *INOUT, 
                'code' : $jniinput, 
                'type' : p.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Boolean;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide bool *INOUT directorin typemap, bool array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) bool *INOUT, 
                'code' : {
}, 
                'type' : p.bool, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) bool *INOUT, 
                'code' : { jenv->ReleaseBooleanArrayElements($input, (jboolean *)$1, 0); }, 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) bool *INOUT, 
                'code' : $javacall, 
                'type' : p.bool, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) bool *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetBooleanArrayElements($input, 0); 
}, 
                'type' : p.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide bool *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) bool *INOUT, 
                'code' : {
}, 
                'type' : p.bool, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1015, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) bool *INOUT, 
                'code' : , 
                'type' : p.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) bool *INOUT, 
                'code' : jbooleanArray, 
                'type' : p.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) bool *INOUT, 
                'code' : boolean[], 
                'type' : p.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) bool *INOUT, 
                'code' : $javainput, 
                'type' : p.bool, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) bool *INPUT, 
                'code' : , 
                'type' : p.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) bool *INPUT, 
                'code' : boolean, 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) bool *INPUT, 
                'code' : $jniinput, 
                'type' : p.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : Z, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) bool *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jboolean *) $1; , 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) bool *INPUT, 
                'code' : $javacall, 
                'type' : p.bool, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) bool *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) bool *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) bool *INPUT, 
                'code' : jboolean, 
                'type' : p.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) bool *INPUT, 
                'code' : boolean, 
                'type' : p.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) bool *INPUT, 
                'code' : $javainput, 
                'type' : p.bool, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 15, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) bool *INPUT, 
                'code' : , 
                'type' : p.bool, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) bool *OUTPUT, 
                'code' : , 
                'type' : p.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) bool *OUTPUT, 
                'code' : boolean[], 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) bool *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Boolean;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide bool *OUTPUT directorin typemap, bool array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) bool *OUTPUT, 
                'code' : {
}, 
                'type' : p.bool, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) bool *OUTPUT, 
                'code' : {
  jboolean jvalue = (jboolean)temp$argnum;
  jenv->SetBooleanArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) bool *OUTPUT, 
                'code' : $javacall, 
                'type' : p.bool, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) bool *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide bool *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) bool *OUTPUT, 
                'code' : {
}, 
                'type' : p.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) bool *OUTPUT, 
                'code' : jbooleanArray, 
                'type' : p.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) bool *OUTPUT, 
                'code' : boolean[], 
                'type' : p.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) bool *OUTPUT, 
                'code' : $javainput, 
                'type' : p.bool, 
            }
, 
        }
, 
    }
, 
    'jdoubleArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jdoubleArray, 
            'code' : double[], 
            'type' : jdoubleArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [D, 
            }
, 
            'typemap' : typemap(directorin) jdoubleArray, 
            'code' : $input = $1;, 
            'type' : jdoubleArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jdoubleArray, 
            'code' : $jniinput, 
            'type' : jdoubleArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jdoubleArray, 
            'code' :  $1 = $input; , 
            'type' : jdoubleArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jdoubleArray, 
            'code' :  $result = $input; , 
            'type' : jdoubleArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jdoubleArray, 
            'code' : $javacall, 
            'type' : jdoubleArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jdoubleArray, 
            'code' : jdoubleArray, 
            'type' : jdoubleArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jdoubleArray, 
            'code' : double[], 
            'type' : jdoubleArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jdoubleArray, 
            'code' :  $result = $1; , 
            'type' : jdoubleArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1090, 
            }
, 
            'typemap' : typemap(typecheck) jdoubleArray, 
            'code' : , 
            'type' : jdoubleArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jdoubleArray, 
            'code' : $javainput, 
            'type' : jdoubleArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jdoubleArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jdoubleArray, 
        }
, 
    }
, 
    'jbyteArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jbyteArray, 
            'code' : byte[], 
            'type' : jbyteArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [B, 
            }
, 
            'typemap' : typemap(directorin) jbyteArray, 
            'code' : $input = $1;, 
            'type' : jbyteArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jbyteArray, 
            'code' : $jniinput, 
            'type' : jbyteArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jbyteArray, 
            'code' :  $1 = $input; , 
            'type' : jbyteArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jbyteArray, 
            'code' :  $result = $input; , 
            'type' : jbyteArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jbyteArray, 
            'code' : $javacall, 
            'type' : jbyteArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jbyteArray, 
            'code' : jbyteArray, 
            'type' : jbyteArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jbyteArray, 
            'code' : byte[], 
            'type' : jbyteArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jbyteArray, 
            'code' :  $result = $1; , 
            'type' : jbyteArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1025, 
            }
, 
            'typemap' : typemap(typecheck) jbyteArray, 
            'code' : , 
            'type' : jbyteArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jbyteArray, 
            'code' : $javainput, 
            'type' : jbyteArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jbyteArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jbyteArray, 
        }
, 
    }
, 
    'struct CharStarByteArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) struct CharStarByteArray, 
            'code' : byte[], 
            'type' : struct CharStarByteArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) struct CharStarByteArray, 
            'code' : jbyteArray, 
            'type' : struct CharStarByteArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) struct CharStarByteArray, 
            'code' : byte[], 
            'type' : struct CharStarByteArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) struct CharStarByteArray, 
            'code' : {
		$result = SWIG_JavaArrayOutSChar(jenv, $1.data, $1.length);
		free((void*)$1.data);
	}, 
            'type' : struct CharStarByteArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) struct CharStarByteArray, 
            'code' : { return $jnicall; }, 
            'type' : struct CharStarByteArray, 
        }
, 
    }
, 
    'jshort' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jshort, 
            'code' : short, 
            'type' : jshort, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : S, 
            }
, 
            'typemap' : typemap(directorin) jshort, 
            'code' : $input = $1;, 
            'type' : jshort, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jshort, 
            'code' : $jniinput, 
            'type' : jshort, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jshort, 
            'code' :  $1 = $input; , 
            'type' : jshort, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jshort, 
            'code' :  $result = $input; , 
            'type' : jshort, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jshort, 
            'code' : $javacall, 
            'type' : jshort, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jshort, 
            'code' : jshort, 
            'type' : jshort, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jshort, 
            'code' : short, 
            'type' : jshort, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jshort, 
            'code' :  $result = $1; , 
            'type' : jshort, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 35, 
            }
, 
            'typemap' : typemap(typecheck) jshort, 
            'code' : , 
            'type' : jshort, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jshort, 
            'code' : $javainput, 
            'type' : jshort, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jshort, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jshort, 
        }
, 
    }
, 
    'jobjectArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jobjectArray, 
            'code' : Object[], 
            'type' : jobjectArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [Ljava/lang/Object;, 
                'nextSibling' : Hash {
                    'name' : nouse, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(directorin) jobjectArray, 
            'code' : $input = $1;, 
            'type' : jobjectArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jobjectArray, 
            'code' : $jniinput, 
            'type' : jobjectArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jobjectArray, 
            'code' :  $1 = $input; , 
            'type' : jobjectArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jobjectArray, 
            'code' :  $result = $input; , 
            'type' : jobjectArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jobjectArray, 
            'code' : $javacall, 
            'type' : jobjectArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jobjectArray, 
            'code' : jobjectArray, 
            'type' : jobjectArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jobjectArray, 
            'code' : Object[], 
            'type' : jobjectArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jobjectArray, 
            'code' :  $result = $1; , 
            'type' : jobjectArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1150, 
            }
, 
            'typemap' : typemap(typecheck) jobjectArray, 
            'code' : , 
            'type' : jobjectArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jobjectArray, 
            'code' : $javainput, 
            'type' : jobjectArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jobjectArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jobjectArray, 
        }
, 
    }
, 
    'jfloatArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jfloatArray, 
            'code' : float[], 
            'type' : jfloatArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [F, 
            }
, 
            'typemap' : typemap(directorin) jfloatArray, 
            'code' : $input = $1;, 
            'type' : jfloatArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jfloatArray, 
            'code' : $jniinput, 
            'type' : jfloatArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jfloatArray, 
            'code' :  $1 = $input; , 
            'type' : jfloatArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jfloatArray, 
            'code' :  $result = $input; , 
            'type' : jfloatArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jfloatArray, 
            'code' : $javacall, 
            'type' : jfloatArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jfloatArray, 
            'code' : jfloatArray, 
            'type' : jfloatArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jfloatArray, 
            'code' : float[], 
            'type' : jfloatArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jfloatArray, 
            'code' :  $result = $1; , 
            'type' : jfloatArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1080, 
            }
, 
            'typemap' : typemap(typecheck) jfloatArray, 
            'code' : , 
            'type' : jfloatArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jfloatArray, 
            'code' : $javainput, 
            'type' : jfloatArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jfloatArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jfloatArray, 
        }
, 
    }
, 
    'enum SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) enum SWIGTYPE, 
            'code' : , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) enum SWIGTYPE, 
            'code' : , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) enum SWIGTYPE, 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) enum SWIGTYPE, 
            'code' : int, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) enum SWIGTYPE, 
            'code' : $javaclassname.swigToEnum($jniinput), 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) enum SWIGTYPE, 
            'code' : $input = (jint) $1;, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) enum SWIGTYPE, 
            'code' : 
  public final int swigValue() {
    return swigValue;
  }

  public String toString() {
    return swigName;
  }

  public static $javaclassname swigToEnum(int swigValue) {
    if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
      return swigValues[swigValue];
    for (int i = 0; i < swigValues.length; i++)
      if (swigValues[i].swigValue == swigValue)
        return swigValues[i];
    throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
  }

  private $javaclassname(String swigName) {
    this.swigName = swigName;
    this.swigValue = swigNext++;
  }

  private $javaclassname(String swigName, int swigValue) {
    this.swigName = swigName;
    this.swigValue = swigValue;
    swigNext = swigValue+1;
  }

  private $javaclassname(String swigName, $javaclassname swigEnum) {
    this.swigName = swigName;
    this.swigValue = swigEnum.swigValue;
    swigNext = this.swigValue+1;
  }

  private static $javaclassname[] swigValues = { $enumvalues };
  private static int swigNext = 0;
  private final int swigValue;
  private final String swigName;
, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) enum SWIGTYPE, 
            'code' : ($javacall).swigValue(), 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) enum SWIGTYPE, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) enum SWIGTYPE, 
            'code' :  $result = (jint)$1; , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) enum SWIGTYPE, 
            'code' : jint, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) enum SWIGTYPE, 
            'code' : {
    return $javaclassname.swigToEnum($jnicall);
  }, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) enum SWIGTYPE, 
            'code' : public final $static class, 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) enum SWIGTYPE, 
            'code' : , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) enum SWIGTYPE, 
            'code' : $javainput.swigValue(), 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) enum SWIGTYPE, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) enum SWIGTYPE, 
            'code' : , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) enum SWIGTYPE, 
            'code' : , 
            'type' : enum SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) enum SWIGTYPE, 
            'code' : $javaclassname, 
            'type' : enum SWIGTYPE, 
        }
, 
    }
, 
    'r.q(const).enum SWIGTYPE' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) enum SWIGTYPE const &, 
            'code' : $*javaclassname, 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$*javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) enum SWIGTYPE const &, 
            'code' : $input = (jint)$1_name;, 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) enum SWIGTYPE const &, 
            'code' : $*javaclassname.swigToEnum($jniinput), 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) enum SWIGTYPE const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) enum SWIGTYPE const &, 
            'code' :  static $*1_ltype temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) enum SWIGTYPE const &, 
            'code' : ($javacall).swigValue(), 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) enum SWIGTYPE const &, 
            'code' : jint, 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) enum SWIGTYPE const &, 
            'code' : int, 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) enum SWIGTYPE const &, 
            'code' :  $result = (jint)*$1; , 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) enum SWIGTYPE const &, 
            'code' : , 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) enum SWIGTYPE const &, 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); , 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) enum SWIGTYPE const &, 
            'code' : $javainput.swigValue(), 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) enum SWIGTYPE const &, 
            'code' : {
    return $*javaclassname.swigToEnum($jnicall);
  }, 
            'type' : r.q(const).enum SWIGTYPE, 
        }
, 
    }
, 
    'r.a(ANY).SWIGTYPE' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE (&)[ANY], 
            'code' : $javaclassname, 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) SWIGTYPE (&)[ANY], 
            'code' :  *($&1_ltype)&$input = ($1_ltype) &$1; , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) SWIGTYPE (&)[ANY], 
            'code' : new $javaclassname($jniinput, false), 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE (&)[ANY], 
            'code' :  $1 = *($&1_ltype)&$input;
  if(!$1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
    return $null;
  } , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 473:Returning a pointer or reference in a director method is not recommended., 
            }
, 
            'typemap' : typemap(directorout) SWIGTYPE (&)[ANY], 
            'code' :  if (!$input) {
     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
     return $null;
   }
   $result = *($&1_ltype)&$input; , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) SWIGTYPE (&)[ANY], 
            'code' : $javaclassname.getCPtr($javacall), 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE (&)[ANY], 
            'code' : jlong, 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE (&)[ANY], 
            'code' : long, 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE (&)[ANY], 
            'code' :  *($&1_ltype)&$result = $1; , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE (&)[ANY], 
            'code' : , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE (&)[ANY], 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE (&)[ANY], 
            'code' : $javaclassname.getCPtr($javainput), 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE (&)[ANY], 
            'code' : {
    return new $javaclassname($jnicall, $owner);
  }, 
            'type' : r.a(ANY).SWIGTYPE, 
        }
, 
    }
, 
    'r.p.SWIGTYPE' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE *&, 
            'code' : $*javaclassname, 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'value' : 0, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE *&, 
            'code' :  temp = *($1_ltype)&$input;
   $1 = &temp; , 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE *&, 
            'code' : jlong, 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE *&, 
            'code' : long, 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE *&, 
            'code' : $*javaclassname.getCPtr($javainput), 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE *&, 
            'code' :  *($1_ltype)&$result = *$1; , 
            'type' : r.p.SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE *&, 
            'code' : {
    long cPtr = $jnicall;
    return (cPtr == 0) ? null : new $*javaclassname(cPtr, $owner);
  }, 
            'type' : r.p.SWIGTYPE, 
        }
, 
    }
, 
    'm(CLASS).SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE CLASS::*, 
            'code' : , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) SWIGTYPE CLASS::*, 
            'code' : , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE CLASS::*, 
            'code' : long, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) SWIGTYPE CLASS::*, 
            'code' : new $javaclassname($jniinput, false), 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) SWIGTYPE CLASS::*, 
            'code' :  *(($&1_ltype)&$input) = ($1_ltype) $1; , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) SWIGTYPE CLASS::*, 
            'code' : 
  private long swigCPtr;

  protected $javaclassname(long cPtr, boolean futureUse) {
    swigCPtr = cPtr;
  }

  protected $javaclassname() {
    swigCPtr = 0;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) SWIGTYPE CLASS::*, 
            'code' : $javaclassname.getCPtr($javacall), 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 473:Returning a pointer or reference in a director method is not recommended., 
            }
, 
            'typemap' : typemap(directorout) SWIGTYPE CLASS::*, 
            'code' :  $result = *($&1_ltype)&$input; , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE CLASS::*, 
            'code' :  *($&1_ltype)&$result = $1; , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE CLASS::*, 
            'code' : jlong, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE CLASS::*, 
            'code' : {
    long cPtr = $jnicall;
    return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
  }, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) SWIGTYPE CLASS::*, 
            'code' : public class, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) SWIGTYPE CLASS::*, 
            'code' : , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE CLASS::*, 
            'code' : $javaclassname.getCPtr($javainput), 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE CLASS::*, 
            'code' :  $1 = *($&1_ltype)&$input; , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) SWIGTYPE CLASS::*, 
            'code' : , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) SWIGTYPE CLASS::*, 
            'code' : , 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE CLASS::*, 
            'code' : $javaclassname, 
            'type' : m(CLASS).SWIGTYPE, 
        }
, 
    }
, 
    'r.SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE &, 
            'code' : , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) SWIGTYPE &, 
            'code' : , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE &, 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE &, 
            'code' : long, 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) SWIGTYPE &, 
            'code' : new $javaclassname($jniinput, false), 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) SWIGTYPE &, 
            'code' :  *($&1_ltype)&$input = ($1_ltype) &$1; , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) SWIGTYPE &, 
            'code' : 
  private long swigCPtr;

  protected $javaclassname(long cPtr, boolean futureUse) {
    swigCPtr = cPtr;
  }

  protected $javaclassname() {
    swigCPtr = 0;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) SWIGTYPE &, 
            'code' : $javaclassname.getCPtr($javacall), 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 473:Returning a pointer or reference in a director method is not recommended., 
            }
, 
            'typemap' : typemap(directorout) SWIGTYPE &, 
            'code' :  if (!$input) {
     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
     return $null;
   }
   $result = *($&1_ltype)&$input; , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE &, 
            'code' :  *($&1_ltype)&$result = $1; , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE &, 
            'code' : jlong, 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE &, 
            'code' : {
    return new $javaclassname($jnicall, $owner);
  }, 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) SWIGTYPE &, 
            'code' : public class, 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) SWIGTYPE &, 
            'code' : , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE &, 
            'code' : $javaclassname.getCPtr($javainput), 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE &, 
            'code' :  $1 = *($&1_ltype)&$input;
  if(!$1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
    return $null;
  } , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) SWIGTYPE &, 
            'code' : , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) SWIGTYPE &, 
            'code' : , 
            'type' : r.SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE &, 
            'code' : $javaclassname, 
            'type' : r.SWIGTYPE, 
        }
, 
    }
, 
    'a().SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE [], 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE [], 
            'code' : long, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) SWIGTYPE [], 
            'code' : 
  private long swigCPtr;

  protected $javaclassname(long cPtr, boolean futureUse) {
    swigCPtr = cPtr;
  }

  protected $javaclassname() {
    swigCPtr = 0;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE [], 
            'code' :  *($&1_ltype)&$result = $1; , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE [], 
            'code' : jlong, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE [], 
            'code' : {
    long cPtr = $jnicall;
    return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
  }, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) SWIGTYPE [], 
            'code' : public class, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE [], 
            'code' : $javaclassname.getCPtr($javainput), 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE [], 
            'code' :  $1 = *($&1_ltype)&$input; , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE [], 
            'code' : $javaclassname, 
            'type' : a().SWIGTYPE, 
        }
, 
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) SWIGTYPE [], 
            'code' : , 
            'type' : a().SWIGTYPE, 
        }
, 
    }
, 
    'SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE, 
            'code' : , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) SWIGTYPE, 
            'code' : , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javabody_derived' : Hash {
            'typemap' : typemap(javabody_derived) SWIGTYPE, 
            'code' : 
  private long swigCPtr;

  protected $javaclassname(long cPtr, boolean cMemoryOwn) {
    super($imclassname.SWIG$javaclassnameUpcast(cPtr), cMemoryOwn);
    swigCPtr = cPtr;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javadestruct_derived' : Hash {
            'kwargs' : Hash {
                'name' : methodname, 
                'value' : delete, 
                'nextSibling' : Hash {
                    'name' : methodmodifiers, 
                    'value' : public synchronized, 
                }
, 
            }
, 
            'typemap' : typemap(javadestruct_derived) SWIGTYPE, 
            'code' : {
    if(swigCPtr != 0 && swigCMemOwn) {
      swigCMemOwn = false;
      $jnicall;
    }
    swigCPtr = 0;
    super.delete();
  }, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:directorowner_take' : Hash {
            'kwargs' : Hash {
                'name' : methodname, 
                'value' : swigTakeOwnership, 
            }
, 
            'typemap' : typemap(directorowner_take) SWIGTYPE, 
            'code' : 
  public void $methodname() {
    swigCMemOwn = true;
    $jnicall;
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE, 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE, 
            'code' : long, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) SWIGTYPE, 
            'code' : new $&javaclassname($jniinput, false), 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$&javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) SWIGTYPE, 
            'code' :  $input = 0;
   *(($&1_ltype*)&$input) = &$1; , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) SWIGTYPE, 
            'code' : 
  private long swigCPtr;
  protected boolean swigCMemOwn;

  protected $javaclassname(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javaconstruct' : Hash {
            'kwargs' : Hash {
                'name' : directorconnect, 
                'value' : 
    $imclassname.$javaclassname_director_connect(this, swigCPtr, swigCMemOwn, true);, 
            }
, 
            'typemap' : typemap(javaconstruct) SWIGTYPE, 
            'code' : {
    this($imcall, true);$directorconnect
  }, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) SWIGTYPE, 
            'code' : $&javaclassname.getCPtr($javacall), 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'locals' : Hash {
                'name' : argp, 
                'type' : $&1_type, 
            }
, 
            'typemap' : typemap(directorout) SWIGTYPE, 
            'code' :  argp = *($&1_ltype*)&$input; 
   if (!argp) {
     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
     return $null;
   }
   $result = *argp; , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE, 
            'code' :  *($&1_ltype*)&$result = new $1_ltype(($1_ltype &)$1); , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE, 
            'code' : jlong, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javafinalize' : Hash {
            'typemap' : typemap(javafinalize) SWIGTYPE, 
            'code' : 
  protected void finalize() {
    delete();
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE, 
            'code' : {
    return new $&javaclassname($jnicall, true);
  }, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javadestruct' : Hash {
            'kwargs' : Hash {
                'name' : methodname, 
                'value' : delete, 
                'nextSibling' : Hash {
                    'name' : methodmodifiers, 
                    'value' : public synchronized, 
                }
, 
            }
, 
            'typemap' : typemap(javadestruct) SWIGTYPE, 
            'code' : {
    if(swigCPtr != 0 && swigCMemOwn) {
      swigCMemOwn = false;
      $jnicall;
    }
    swigCPtr = 0;
  }, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:directordisconnect' : Hash {
            'kwargs' : Hash {
                'name' : methodname, 
                'value' : swigDirectorDisconnect, 
            }
, 
            'typemap' : typemap(directordisconnect) SWIGTYPE, 
            'code' : 
  protected void $methodname() {
    swigCMemOwn = false;
    $jnicall;
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) SWIGTYPE, 
            'code' : public class, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) SWIGTYPE, 
            'code' : , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE, 
            'code' : $&javaclassname.getCPtr($javainput), 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : argp, 
                'type' : $&1_type, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE, 
            'code' :  argp = *($&1_ltype*)&$input; 
   if (!argp) {
     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
     return $null;
   }
   $1 = *argp; , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) SWIGTYPE, 
            'code' : , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) SWIGTYPE, 
            'code' : , 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:directorowner_release' : Hash {
            'kwargs' : Hash {
                'name' : methodname, 
                'value' : swigReleaseOwnership, 
            }
, 
            'typemap' : typemap(directorowner_release) SWIGTYPE, 
            'code' : 
  public void $methodname() {
    swigCMemOwn = false;
    $jnicall;
  }
, 
            'type' : SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE, 
            'code' : $&javaclassname, 
            'type' : SWIGTYPE, 
        }
, 
        'VARARGS_SENTINEL' : Hash {
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 0, 
                }
, 
                'pname' : VARARGS_SENTINEL, 
                'typemap' : typemap(in) SWIGTYPE VARARGS_SENTINEL, 
                'code' : , 
                'type' : SWIGTYPE, 
            }
, 
        }
, 
    }
, 
    'p.SWIGTYPE' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 0, 
            }
, 
            'typemap' : typemap(typecheck) SWIGTYPE *, 
            'code' : , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javabase' : Hash {
            'typemap' : typemap(javabase) SWIGTYPE *, 
            'code' : , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE *, 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) SWIGTYPE *, 
            'code' : long, 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) SWIGTYPE *, 
            'code' : new $javaclassname($jniinput, false), 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : L$packagepath/$javaclassname;, 
            }
, 
            'typemap' : typemap(directorin) SWIGTYPE *, 
            'code' :  *(($&1_ltype)&$input) = ($1_ltype) $1; , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javabody' : Hash {
            'typemap' : typemap(javabody) SWIGTYPE *, 
            'code' : 
  private long swigCPtr;

  protected $javaclassname(long cPtr, boolean futureUse) {
    swigCPtr = cPtr;
  }

  protected $javaclassname() {
    swigCPtr = 0;
  }

  protected static long getCPtr($javaclassname obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
, 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) SWIGTYPE *, 
            'code' : $javaclassname.getCPtr($javacall), 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 473:Returning a pointer or reference in a director method is not recommended., 
            }
, 
            'typemap' : typemap(directorout) SWIGTYPE *, 
            'code' :  $result = *($&1_ltype)&$input; , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) SWIGTYPE *, 
            'code' :  *($&1_ltype)&$result = $1; , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) SWIGTYPE *, 
            'code' : jlong, 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) SWIGTYPE *, 
            'code' : {
    long cPtr = $jnicall;
    return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
  }, 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javaclassmodifiers' : Hash {
            'typemap' : typemap(javaclassmodifiers) SWIGTYPE *, 
            'code' : public class, 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javacode' : Hash {
            'typemap' : typemap(javacode) SWIGTYPE *, 
            'code' : , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) SWIGTYPE *, 
            'code' : $javaclassname.getCPtr($javainput), 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) SWIGTYPE *, 
            'code' :  $1 = *($&1_ltype)&$input; , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javaimports' : Hash {
            'typemap' : typemap(javaimports) SWIGTYPE *, 
            'code' : , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:javainterfaces' : Hash {
            'typemap' : typemap(javainterfaces) SWIGTYPE *, 
            'code' : , 
            'type' : p.SWIGTYPE, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) SWIGTYPE *, 
            'code' : $javaclassname, 
            'type' : p.SWIGTYPE, 
        }
, 
        'VARARGS_SENTINEL' : Hash {
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 0, 
                }
, 
                'pname' : VARARGS_SENTINEL, 
                'typemap' : typemap(in) SWIGTYPE *VARARGS_SENTINEL, 
                'code' : , 
                'type' : p.SWIGTYPE, 
            }
, 
        }
, 
    }
, 
    'a(ANY).a(ANY).SWIGTYPE' : Hash {
        'tmap:memberin' : Hash {
            'typemap' : typemap(memberin) SWIGTYPE [ANY][ANY], 
            'code' : {
  $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
  $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
  size_t ii = 0;
  for (; ii < $dim0; ++ii) {
    $basetype *ip = inp[ii];
    $basetype *dp = dest[ii];
    size_t jj = 0;
    for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
  }
}, 
            'type' : a(ANY).a(ANY).SWIGTYPE, 
        }
, 
        'tmap:globalin' : Hash {
            'typemap' : typemap(globalin) SWIGTYPE [ANY][ANY], 
            'code' : {
  $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
  $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
  size_t ii = 0;
  for (; ii < $dim0; ++ii) {
    $basetype *ip = inp[ii];
    $basetype *dp = dest[ii];
    size_t jj = 0;
    for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
  }
}, 
            'type' : a(ANY).a(ANY).SWIGTYPE, 
        }
, 
    }
, 
    'a(ANY).SWIGTYPE' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) SWIGTYPE [ANY], 
            'code' : , 
            'type' : a(ANY).SWIGTYPE, 
        }
, 
        'tmap:memberin' : Hash {
            'typemap' : typemap(memberin) SWIGTYPE [ANY], 
            'code' : {
  size_t ii;
  $1_basetype *b = ($1_basetype *) $1;
  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
}, 
            'type' : a(ANY).SWIGTYPE, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) SWIGTYPE [ANY], 
            'code' :  (void)$1;
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
   return $null; , 
            'type' : a(ANY).SWIGTYPE, 
        }
, 
        'tmap:globalin' : Hash {
            'typemap' : typemap(globalin) SWIGTYPE [ANY], 
            'code' : {
  size_t ii;
  $1_basetype *b = ($1_basetype *) $1;
  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
}, 
            'type' : a(ANY).SWIGTYPE, 
        }
, 
    }
, 
    'SWIGBIGINTEGERARRAY' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1065, 
            }
, 
            'typemap' : typemap(typecheck) SWIGBIGINTEGERARRAY, 
            'code' : , 
            'type' : SWIGBIGINTEGERARRAY, 
        }
, 
    }
, 
    'jbooleanArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jbooleanArray, 
            'code' : boolean[], 
            'type' : jbooleanArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [Z, 
            }
, 
            'typemap' : typemap(directorin) jbooleanArray, 
            'code' : $input = $1;, 
            'type' : jbooleanArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jbooleanArray, 
            'code' : $jniinput, 
            'type' : jbooleanArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jbooleanArray, 
            'code' :  $1 = $input; , 
            'type' : jbooleanArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jbooleanArray, 
            'code' :  $result = $input; , 
            'type' : jbooleanArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jbooleanArray, 
            'code' : $javacall, 
            'type' : jbooleanArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jbooleanArray, 
            'code' : jbooleanArray, 
            'type' : jbooleanArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jbooleanArray, 
            'code' : boolean[], 
            'type' : jbooleanArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jbooleanArray, 
            'code' :  $result = $1; , 
            'type' : jbooleanArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1015, 
            }
, 
            'typemap' : typemap(typecheck) jbooleanArray, 
            'code' : , 
            'type' : jbooleanArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jbooleanArray, 
            'code' : $javainput, 
            'type' : jbooleanArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jbooleanArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jbooleanArray, 
        }
, 
    }
, 
    'long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long, 
            'code' : int, 
            'type' : long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) long, 
            'code' : $input = (jint) $1;, 
            'type' : long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) long, 
            'code' : $jniinput, 
            'type' : long, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : long, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) long, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) long, 
            'code' : $javacall, 
            'type' : long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long, 
            'code' : jint, 
            'type' : long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long, 
            'code' : int, 
            'type' : long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long, 
            'code' :  $result = (jint)$1; , 
            'type' : long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) long, 
            'code' : , 
            'type' : long, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) long, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long, 
            'code' : $javainput, 
            'type' : long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long, 
            'code' : {
    return $jnicall;
  }, 
            'type' : long, 
        }
, 
    }
, 
    'jobject' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jobject, 
            'code' : Object, 
            'type' : jobject, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/lang/Object;, 
                'nextSibling' : Hash {
                    'name' : nouse, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(directorin) jobject, 
            'code' : $input = $1;, 
            'type' : jobject, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jobject, 
            'code' : $jniinput, 
            'type' : jobject, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jobject, 
            'code' :  $1 = $input; , 
            'type' : jobject, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jobject, 
            'code' :  $result = $input; , 
            'type' : jobject, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jobject, 
            'code' : $javacall, 
            'type' : jobject, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jobject, 
            'code' : jobject, 
            'type' : jobject, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jobject, 
            'code' : Object, 
            'type' : jobject, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jobject, 
            'code' :  $result = $1; , 
            'type' : jobject, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jobject, 
            'code' : $javainput, 
            'type' : jobject, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jobject, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jobject, 
        }
, 
    }
, 
    'unsigned int' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned int, 
            'code' : long, 
            'type' : unsigned int, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) unsigned int, 
            'code' : $input = (jlong) $1;, 
            'type' : unsigned int, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned int, 
            'code' : $jniinput, 
            'type' : unsigned int, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned int, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : unsigned int, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) unsigned int, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : unsigned int, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned int, 
            'code' : $javacall, 
            'type' : unsigned int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned int, 
            'code' : jlong, 
            'type' : unsigned int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned int, 
            'code' : long, 
            'type' : unsigned int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned int, 
            'code' :  $result = (jlong)$1; , 
            'type' : unsigned int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) unsigned int, 
            'code' : , 
            'type' : unsigned int, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) unsigned int, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : unsigned int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned int, 
            'code' : $javainput, 
            'type' : unsigned int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned int, 
            'code' : {
    return $jnicall;
  }, 
            'type' : unsigned int, 
        }
, 
    }
, 
    'r.q(const).unsigned int' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned int const &, 
            'code' : long, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) unsigned int const &, 
            'code' : $input = (jlong)$1_name;, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) unsigned int const &, 
            'code' : $jniinput, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned int const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) unsigned int const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) unsigned int const &, 
            'code' : $javacall, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned int const &, 
            'code' : jlong, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned int const &, 
            'code' : long, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned int const &, 
            'code' :  $result = (jlong)*$1; , 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) unsigned int const &, 
            'code' : , 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned int const &, 
            'code' : $javainput, 
            'type' : r.q(const).unsigned int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned int const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).unsigned int, 
        }
, 
    }
, 
    'p.unsigned int' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned int *INOUT, 
                'code' : , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned int *INOUT, 
                'code' : long[], 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned int *INOUT, 
                'code' : $jniinput, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned int *INOUT directorin typemap, unsigned int array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned int *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned int *INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned int *INOUT, 
                'code' : $javacall, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned int *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned int *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned int *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned int *INOUT, 
                'code' : , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned int *INOUT, 
                'code' : jlongArray, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned int *INOUT, 
                'code' : long[], 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned int *INOUT, 
                'code' : $javainput, 
                'type' : p.unsigned int, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned int *INPUT, 
                'code' : , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned int *INPUT, 
                'code' : long, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned int *INPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned int *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) $1; , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned int *INPUT, 
                'code' : $javacall, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned int *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned int *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned int *INPUT, 
                'code' : jlong, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned int *INPUT, 
                'code' : long, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned int *INPUT, 
                'code' : $javainput, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned int *INPUT, 
                'code' : , 
                'type' : p.unsigned int, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned int *OUTPUT, 
                'code' : , 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned int *OUTPUT, 
                'code' : long[], 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned int *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned int *OUTPUT directorin typemap, unsigned int array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned int *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned int *OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned int *OUTPUT, 
                'code' : $javacall, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned int *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned int *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned int *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned int *OUTPUT, 
                'code' : jlongArray, 
                'type' : p.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned int *OUTPUT, 
                'code' : long[], 
                'type' : p.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned int *OUTPUT, 
                'code' : $javainput, 
                'type' : p.unsigned int, 
            }
, 
        }
, 
    }
, 
    'r.unsigned int' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned int &INOUT, 
                'code' : , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned int &INOUT, 
                'code' : long[], 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned int &INOUT, 
                'code' : $jniinput, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned int *INOUT directorin typemap, unsigned int array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned int &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned int &INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned int &INOUT, 
                'code' : $javacall, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned int &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned int *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned int &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned int &INOUT, 
                'code' : , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned int &INOUT, 
                'code' : jlongArray, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned int &INOUT, 
                'code' : long[], 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned int &INOUT, 
                'code' : $javainput, 
                'type' : r.unsigned int, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned int &INPUT, 
                'code' : , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned int &INPUT, 
                'code' : long, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned int &INPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned int &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) &$1; , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned int &INPUT, 
                'code' : $javacall, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned int &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned int &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned int &INPUT, 
                'code' : jlong, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned int &INPUT, 
                'code' : long, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned int &INPUT, 
                'code' : $javainput, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned int &INPUT, 
                'code' : , 
                'type' : r.unsigned int, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned int &OUTPUT, 
                'code' : , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned int &OUTPUT, 
                'code' : long[], 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned int &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned int &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.unsigned int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned int &OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned int &OUTPUT, 
                'code' : $javacall, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned int &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned int *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned int &OUTPUT, 
                'code' : {
}, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned int &OUTPUT, 
                'code' : jlongArray, 
                'type' : r.unsigned int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned int &OUTPUT, 
                'code' : long[], 
                'type' : r.unsigned int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned int &OUTPUT, 
                'code' : $javainput, 
                'type' : r.unsigned int, 
            }
, 
        }
, 
    }
, 
    'a(ANY).unsigned int' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned int [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned int [ANY], 
            'code' : long[], 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned int [ANY], 
            'code' :  SWIG_JavaArrayArgoutUint(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned int [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInUint(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned int [ANY], 
            'code' : jlongArray, 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned int [ANY], 
            'code' : long[], 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned int [ANY], 
            'code' : $result = SWIG_JavaArrayOutUint(jenv, $1, $1_dim0); , 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned int [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) unsigned int [ANY], 
            'code' : , 
            'type' : a(ANY).unsigned int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned int [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).unsigned int, 
        }
, 
    }
, 
    'a().unsigned int' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned int [], 
            'code' :  delete [] $1; , 
            'type' : a().unsigned int, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned int [], 
            'code' : long[], 
            'type' : a().unsigned int, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned int [], 
            'code' :  SWIG_JavaArrayArgoutUint(jenv, jarr$argnum, $1, $input); , 
            'type' : a().unsigned int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned int [], 
            'code' :   if (!SWIG_JavaArrayInUint(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().unsigned int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned int [], 
            'code' : jlongArray, 
            'type' : a().unsigned int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned int [], 
            'code' : long[], 
            'type' : a().unsigned int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned int [], 
            'code' : $result = SWIG_JavaArrayOutUint(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().unsigned int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned int [], 
            'code' : $javainput, 
            'type' : a().unsigned int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) unsigned int [], 
            'code' : , 
            'type' : a().unsigned int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned int [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().unsigned int, 
        }
, 
    }
, 
    'a(ANY).long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) long [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) long [ANY], 
            'code' : int[], 
            'type' : a(ANY).long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) long [ANY], 
            'code' :  SWIG_JavaArrayArgoutLong(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) long [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInLong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) long [ANY], 
            'code' : jintArray, 
            'type' : a(ANY).long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) long [ANY], 
            'code' : int[], 
            'type' : a(ANY).long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) long [ANY], 
            'code' : $result = SWIG_JavaArrayOutLong(jenv, $1, $1_dim0); , 
            'type' : a(ANY).long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) long [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) long [ANY], 
            'code' : , 
            'type' : a(ANY).long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) long [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).long, 
        }
, 
    }
, 
    'char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) char, 
            'code' : char, 
            'type' : char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : C, 
            }
, 
            'typemap' : typemap(directorin) char, 
            'code' : $input = (jint) $1;, 
            'type' : char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) char, 
            'code' : $jniinput, 
            'type' : char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) char, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : char, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) char, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) char, 
            'code' : $javacall, 
            'type' : char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) char, 
            'code' : jchar, 
            'type' : char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) char, 
            'code' : char, 
            'type' : char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) char, 
            'code' :  $result = (jchar)$1; , 
            'type' : char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 130, 
            }
, 
            'typemap' : typemap(typecheck) char, 
            'code' : , 
            'type' : char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) char, 
            'code' : $javainput, 
            'type' : char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) char, 
            'code' : {
    return $jnicall;
  }, 
            'type' : char, 
        }
, 
    }
, 
    'jstring' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jstring, 
            'code' : String, 
            'type' : jstring, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/lang/String;, 
            }
, 
            'typemap' : typemap(directorin) jstring, 
            'code' : $input = $1;, 
            'type' : jstring, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jstring, 
            'code' : $jniinput, 
            'type' : jstring, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jstring, 
            'code' :  $1 = $input; , 
            'type' : jstring, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jstring, 
            'code' :  $result = $input; , 
            'type' : jstring, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jstring, 
            'code' : $javacall, 
            'type' : jstring, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jstring, 
            'code' : jstring, 
            'type' : jstring, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jstring, 
            'code' : String, 
            'type' : jstring, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jstring, 
            'code' :  $result = $1; , 
            'type' : jstring, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 140, 
            }
, 
            'typemap' : typemap(typecheck) jstring, 
            'code' : , 
            'type' : jstring, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jstring, 
            'code' : $javainput, 
            'type' : jstring, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jstring, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jstring, 
        }
, 
    }
, 
    'jlong' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jlong, 
            'code' : long, 
            'type' : jlong, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) jlong, 
            'code' : $input = $1;, 
            'type' : jlong, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jlong, 
            'code' : $jniinput, 
            'type' : jlong, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jlong, 
            'code' :  $1 = $input; , 
            'type' : jlong, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jlong, 
            'code' :  $result = $input; , 
            'type' : jlong, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jlong, 
            'code' : $javacall, 
            'type' : jlong, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jlong, 
            'code' : jlong, 
            'type' : jlong, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jlong, 
            'code' : long, 
            'type' : jlong, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jlong, 
            'code' :  $result = $1; , 
            'type' : jlong, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) jlong, 
            'code' : , 
            'type' : jlong, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jlong, 
            'code' : $javainput, 
            'type' : jlong, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jlong, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jlong, 
        }
, 
    }
, 
    'a(ANY).char' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 140, 
            }
, 
            'typemap' : typemap(typecheck) char [ANY], 
            'code' : , 
            'type' : a(ANY).char, 
        }
, 
        'tmap:memberin' : Hash {
            'typemap' : typemap(memberin) char [ANY], 
            'code' : {
  if ($input) strncpy((char *)$1, (const char *)$input, $1_dim0);
  else $1[0] = 0;
}, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) char [ANY], 
            'code' : String, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) char [ANY], 
            'code' : $jniinput, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/lang/String;, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(directorin) char [ANY], 
            'code' : $input = 0;
  if ($1) {
    $input = jenv->NewStringUTF((const char *)$1);
    if (!$input) return $null;
  }, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) char [ANY], 
            'code' : $javacall, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(directorout) char [ANY], 
            'code' : $1 = 0;
  if ($input) {
    $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$result) return $null;
  }, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:out' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(out) char [ANY], 
            'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) char [ANY], 
            'code' : jstring, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) char [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:globalin' : Hash {
            'typemap' : typemap(globalin) char [ANY], 
            'code' : {
  if ($input) strncpy((char *)$1, (const char *)$input, $1_dim0);
  else $1[0] = 0;
}, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(in) char [ANY], 
            'code' : $1 = 0;
  if ($input) {
    $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$1) return $null;
  }, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) char [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) char [ANY], 
            'code' : String, 
            'type' : a(ANY).char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) char [ANY], 
            'code' : , 
            'type' : a(ANY).char, 
        }
, 
        'tmap:freearg' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(freearg) char [ANY], 
            'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);, 
            'type' : a(ANY).char, 
        }
, 
    }
, 
    'r.bool' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) bool &INOUT, 
                'code' : , 
                'type' : r.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) bool &INOUT, 
                'code' : boolean[], 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) bool &INOUT, 
                'code' : $jniinput, 
                'type' : r.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Boolean;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide bool *INOUT directorin typemap, bool array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) bool &INOUT, 
                'code' : {
}, 
                'type' : r.bool, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) bool &INOUT, 
                'code' : { jenv->ReleaseBooleanArrayElements($input, (jboolean *)$1, 0); }, 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) bool &INOUT, 
                'code' : $javacall, 
                'type' : r.bool, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) bool &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetBooleanArrayElements($input, 0); 
}, 
                'type' : r.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide bool *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) bool &INOUT, 
                'code' : {
}, 
                'type' : r.bool, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1015, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) bool &INOUT, 
                'code' : , 
                'type' : r.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) bool &INOUT, 
                'code' : jbooleanArray, 
                'type' : r.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) bool &INOUT, 
                'code' : boolean[], 
                'type' : r.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) bool &INOUT, 
                'code' : $javainput, 
                'type' : r.bool, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) bool &INPUT, 
                'code' : , 
                'type' : r.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) bool &INPUT, 
                'code' : boolean, 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) bool &INPUT, 
                'code' : $jniinput, 
                'type' : r.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : Z, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) bool &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jboolean *) &$1; , 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) bool &INPUT, 
                'code' : $javacall, 
                'type' : r.bool, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) bool &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) bool &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) bool &INPUT, 
                'code' : jboolean, 
                'type' : r.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) bool &INPUT, 
                'code' : boolean, 
                'type' : r.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) bool &INPUT, 
                'code' : $javainput, 
                'type' : r.bool, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 15, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) bool &INPUT, 
                'code' : , 
                'type' : r.bool, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) bool &OUTPUT, 
                'code' : , 
                'type' : r.bool, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) bool &OUTPUT, 
                'code' : boolean[], 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) bool &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.bool, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Boolean;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) bool &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.bool, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) bool &OUTPUT, 
                'code' : {
  jboolean jvalue = (jboolean)temp$argnum;
  jenv->SetBooleanArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.bool, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) bool &OUTPUT, 
                'code' : $javacall, 
                'type' : r.bool, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) bool &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.bool, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide bool *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) bool &OUTPUT, 
                'code' : {
}, 
                'type' : r.bool, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) bool &OUTPUT, 
                'code' : jbooleanArray, 
                'type' : r.bool, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) bool &OUTPUT, 
                'code' : boolean[], 
                'type' : r.bool, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) bool &OUTPUT, 
                'code' : $javainput, 
                'type' : r.bool, 
            }
, 
        }
, 
    }
, 
    'jlongArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jlongArray, 
            'code' : long[], 
            'type' : jlongArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [J, 
            }
, 
            'typemap' : typemap(directorin) jlongArray, 
            'code' : $input = $1;, 
            'type' : jlongArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jlongArray, 
            'code' : $jniinput, 
            'type' : jlongArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jlongArray, 
            'code' :  $1 = $input; , 
            'type' : jlongArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jlongArray, 
            'code' :  $result = $input; , 
            'type' : jlongArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jlongArray, 
            'code' : $javacall, 
            'type' : jlongArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jlongArray, 
            'code' : jlongArray, 
            'type' : jlongArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jlongArray, 
            'code' : long[], 
            'type' : jlongArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jlongArray, 
            'code' :  $result = $1; , 
            'type' : jlongArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) jlongArray, 
            'code' : , 
            'type' : jlongArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jlongArray, 
            'code' : $javainput, 
            'type' : jlongArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jlongArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jlongArray, 
        }
, 
    }
, 
    'jchar' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jchar, 
            'code' : char, 
            'type' : jchar, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : C, 
            }
, 
            'typemap' : typemap(directorin) jchar, 
            'code' : $input = $1;, 
            'type' : jchar, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jchar, 
            'code' : $jniinput, 
            'type' : jchar, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jchar, 
            'code' :  $1 = $input; , 
            'type' : jchar, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jchar, 
            'code' :  $result = $input; , 
            'type' : jchar, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jchar, 
            'code' : $javacall, 
            'type' : jchar, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jchar, 
            'code' : jchar, 
            'type' : jchar, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jchar, 
            'code' : char, 
            'type' : jchar, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jchar, 
            'code' :  $result = $1; , 
            'type' : jchar, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 130, 
            }
, 
            'typemap' : typemap(typecheck) jchar, 
            'code' : , 
            'type' : jchar, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jchar, 
            'code' : $javainput, 
            'type' : jchar, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jchar, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jchar, 
        }
, 
    }
, 
    'jboolean' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jboolean, 
            'code' : boolean, 
            'type' : jboolean, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Z, 
            }
, 
            'typemap' : typemap(directorin) jboolean, 
            'code' : $input = $1;, 
            'type' : jboolean, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jboolean, 
            'code' : $jniinput, 
            'type' : jboolean, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jboolean, 
            'code' :  $1 = $input; , 
            'type' : jboolean, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jboolean, 
            'code' :  $result = $input; , 
            'type' : jboolean, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jboolean, 
            'code' : $javacall, 
            'type' : jboolean, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jboolean, 
            'code' : jboolean, 
            'type' : jboolean, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jboolean, 
            'code' : boolean, 
            'type' : jboolean, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jboolean, 
            'code' :  $result = $1; , 
            'type' : jboolean, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 15, 
            }
, 
            'typemap' : typemap(typecheck) jboolean, 
            'code' : , 
            'type' : jboolean, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jboolean, 
            'code' : $javainput, 
            'type' : jboolean, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jboolean, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jboolean, 
        }
, 
    }
, 
    'p.float' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) float *INOUT, 
                'code' : , 
                'type' : p.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) float *INOUT, 
                'code' : float[], 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) float *INOUT, 
                'code' : $jniinput, 
                'type' : p.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Float;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide float *INOUT directorin typemap, float array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) float *INOUT, 
                'code' : {
}, 
                'type' : p.float, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) float *INOUT, 
                'code' : { jenv->ReleaseFloatArrayElements($input, (jfloat *)$1, 0); }, 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) float *INOUT, 
                'code' : $javacall, 
                'type' : p.float, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) float *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetFloatArrayElements($input, 0); 
}, 
                'type' : p.float, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide float *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) float *INOUT, 
                'code' : {
}, 
                'type' : p.float, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1080, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) float *INOUT, 
                'code' : , 
                'type' : p.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) float *INOUT, 
                'code' : jfloatArray, 
                'type' : p.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) float *INOUT, 
                'code' : float[], 
                'type' : p.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) float *INOUT, 
                'code' : $javainput, 
                'type' : p.float, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) float *INPUT, 
                'code' : , 
                'type' : p.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) float *INPUT, 
                'code' : float, 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) float *INPUT, 
                'code' : $jniinput, 
                'type' : p.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : F, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) float *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jfloat *) $1; , 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) float *INPUT, 
                'code' : $javacall, 
                'type' : p.float, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) float *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.float, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) float *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) float *INPUT, 
                'code' : jfloat, 
                'type' : p.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) float *INPUT, 
                'code' : float, 
                'type' : p.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) float *INPUT, 
                'code' : $javainput, 
                'type' : p.float, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 80, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) float *INPUT, 
                'code' : , 
                'type' : p.float, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) float *OUTPUT, 
                'code' : , 
                'type' : p.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) float *OUTPUT, 
                'code' : float[], 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) float *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Float;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide float *OUTPUT directorin typemap, float array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) float *OUTPUT, 
                'code' : {
}, 
                'type' : p.float, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) float *OUTPUT, 
                'code' : {
  jfloat jvalue = (jfloat)temp$argnum;
  jenv->SetFloatArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) float *OUTPUT, 
                'code' : $javacall, 
                'type' : p.float, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) float *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.float, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide float *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) float *OUTPUT, 
                'code' : {
}, 
                'type' : p.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) float *OUTPUT, 
                'code' : jfloatArray, 
                'type' : p.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) float *OUTPUT, 
                'code' : float[], 
                'type' : p.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) float *OUTPUT, 
                'code' : $javainput, 
                'type' : p.float, 
            }
, 
        }
, 
    }
, 
    'r.float' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) float &INOUT, 
                'code' : , 
                'type' : r.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) float &INOUT, 
                'code' : float[], 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) float &INOUT, 
                'code' : $jniinput, 
                'type' : r.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Float;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide float *INOUT directorin typemap, float array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) float &INOUT, 
                'code' : {
}, 
                'type' : r.float, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) float &INOUT, 
                'code' : { jenv->ReleaseFloatArrayElements($input, (jfloat *)$1, 0); }, 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) float &INOUT, 
                'code' : $javacall, 
                'type' : r.float, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) float &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetFloatArrayElements($input, 0); 
}, 
                'type' : r.float, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide float *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) float &INOUT, 
                'code' : {
}, 
                'type' : r.float, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1080, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) float &INOUT, 
                'code' : , 
                'type' : r.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) float &INOUT, 
                'code' : jfloatArray, 
                'type' : r.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) float &INOUT, 
                'code' : float[], 
                'type' : r.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) float &INOUT, 
                'code' : $javainput, 
                'type' : r.float, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) float &INPUT, 
                'code' : , 
                'type' : r.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) float &INPUT, 
                'code' : float, 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) float &INPUT, 
                'code' : $jniinput, 
                'type' : r.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : F, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) float &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jfloat *) &$1; , 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) float &INPUT, 
                'code' : $javacall, 
                'type' : r.float, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) float &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.float, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) float &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) float &INPUT, 
                'code' : jfloat, 
                'type' : r.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) float &INPUT, 
                'code' : float, 
                'type' : r.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) float &INPUT, 
                'code' : $javainput, 
                'type' : r.float, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 80, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) float &INPUT, 
                'code' : , 
                'type' : r.float, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) float &OUTPUT, 
                'code' : , 
                'type' : r.float, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) float &OUTPUT, 
                'code' : float[], 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) float &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.float, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Float;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) float &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.float, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) float &OUTPUT, 
                'code' : {
  jfloat jvalue = (jfloat)temp$argnum;
  jenv->SetFloatArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.float, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) float &OUTPUT, 
                'code' : $javacall, 
                'type' : r.float, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) float &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.float, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide float *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) float &OUTPUT, 
                'code' : {
}, 
                'type' : r.float, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) float &OUTPUT, 
                'code' : jfloatArray, 
                'type' : r.float, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) float &OUTPUT, 
                'code' : float[], 
                'type' : r.float, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) float &OUTPUT, 
                'code' : $javainput, 
                'type' : r.float, 
            }
, 
        }
, 
    }
, 
    'a(ANY).ARRAYSOFENUMS' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) ARRAYSOFENUMS [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) ARRAYSOFENUMS [ANY], 
            'code' : int[], 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) ARRAYSOFENUMS [ANY], 
            'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); , 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) ARRAYSOFENUMS [ANY], 
            'code' : {
  if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
}, 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) ARRAYSOFENUMS [ANY], 
            'code' : jintArray, 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) ARRAYSOFENUMS [ANY], 
            'code' : int[], 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) ARRAYSOFENUMS [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) ARRAYSOFENUMS [ANY], 
            'code' : $result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); , 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) ARRAYSOFENUMS [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).ARRAYSOFENUMS, 
        }
, 
    }
, 
    'a().ARRAYSOFENUMS' : Hash {
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) ARRAYSOFENUMS [], 
            'code' :   if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; , 
            'type' : a().ARRAYSOFENUMS, 
        }
, 
    }
, 
    'unsigned long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long, 
            'code' : long, 
            'type' : unsigned long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) unsigned long, 
            'code' : $input = (jlong) $1;, 
            'type' : unsigned long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned long, 
            'code' : $jniinput, 
            'type' : unsigned long, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : unsigned long, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) unsigned long, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : unsigned long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned long, 
            'code' : $javacall, 
            'type' : unsigned long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long, 
            'code' : jlong, 
            'type' : unsigned long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long, 
            'code' : long, 
            'type' : unsigned long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long, 
            'code' :  $result = (jlong)$1; , 
            'type' : unsigned long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long, 
            'code' : , 
            'type' : unsigned long, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) unsigned long, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : unsigned long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long, 
            'code' : $javainput, 
            'type' : unsigned long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long, 
            'code' : {
    return $jnicall;
  }, 
            'type' : unsigned long, 
        }
, 
    }
, 
    'r.q(const).unsigned long' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long const &, 
            'code' : long, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) unsigned long const &, 
            'code' : $input = (jlong)$1_name;, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) unsigned long const &, 
            'code' : $jniinput, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) unsigned long const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) unsigned long const &, 
            'code' : $javacall, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long const &, 
            'code' : jlong, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long const &, 
            'code' : long, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long const &, 
            'code' :  $result = (jlong)*$1; , 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long const &, 
            'code' : , 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long const &, 
            'code' : $javainput, 
            'type' : r.q(const).unsigned long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).unsigned long, 
        }
, 
    }
, 
    'p.long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) long *INOUT, 
                'code' : , 
                'type' : p.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) long *INOUT, 
                'code' : int[], 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) long *INOUT, 
                'code' : $jniinput, 
                'type' : p.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long *INOUT directorin typemap, long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) long *INOUT, 
                'code' : {
}, 
                'type' : p.long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) long *INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) long *INOUT, 
                'code' : $javacall, 
                'type' : p.long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) long *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : p.long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) long *INOUT, 
                'code' : {
}, 
                'type' : p.long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) long *INOUT, 
                'code' : , 
                'type' : p.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) long *INOUT, 
                'code' : jintArray, 
                'type' : p.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) long *INOUT, 
                'code' : int[], 
                'type' : p.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) long *INOUT, 
                'code' : $javainput, 
                'type' : p.long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) long *INPUT, 
                'code' : , 
                'type' : p.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) long *INPUT, 
                'code' : int, 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) long *INPUT, 
                'code' : $jniinput, 
                'type' : p.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) long *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) $1; , 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) long *INPUT, 
                'code' : $javacall, 
                'type' : p.long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) long *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) long *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) long *INPUT, 
                'code' : jint, 
                'type' : p.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) long *INPUT, 
                'code' : int, 
                'type' : p.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) long *INPUT, 
                'code' : $javainput, 
                'type' : p.long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) long *INPUT, 
                'code' : , 
                'type' : p.long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) long *OUTPUT, 
                'code' : , 
                'type' : p.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) long *OUTPUT, 
                'code' : int[], 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) long *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long *OUTPUT directorin typemap, long array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) long *OUTPUT, 
                'code' : {
}, 
                'type' : p.long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) long *OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) long *OUTPUT, 
                'code' : $javacall, 
                'type' : p.long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) long *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) long *OUTPUT, 
                'code' : {
}, 
                'type' : p.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) long *OUTPUT, 
                'code' : jintArray, 
                'type' : p.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) long *OUTPUT, 
                'code' : int[], 
                'type' : p.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) long *OUTPUT, 
                'code' : $javainput, 
                'type' : p.long, 
            }
, 
        }
, 
    }
, 
    'p.unsigned long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned long *INOUT, 
                'code' : , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned long *INOUT, 
                'code' : long[], 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned long *INOUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long *INOUT directorin typemap, unsigned long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned long *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned long *INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned long *INOUT, 
                'code' : $javacall, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned long *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned long *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned long *INOUT, 
                'code' : , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned long *INOUT, 
                'code' : jlongArray, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned long *INOUT, 
                'code' : long[], 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned long *INOUT, 
                'code' : $javainput, 
                'type' : p.unsigned long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned long *INPUT, 
                'code' : , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned long *INPUT, 
                'code' : long, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned long *INPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned long *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) $1; , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned long *INPUT, 
                'code' : $javacall, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned long *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned long *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned long *INPUT, 
                'code' : jlong, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned long *INPUT, 
                'code' : long, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned long *INPUT, 
                'code' : $javainput, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned long *INPUT, 
                'code' : , 
                'type' : p.unsigned long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned long *OUTPUT, 
                'code' : , 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned long *OUTPUT, 
                'code' : long[], 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned long *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long *OUTPUT directorin typemap, unsigned long array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned long *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned long *OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned long *OUTPUT, 
                'code' : $javacall, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned long *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned long *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned long *OUTPUT, 
                'code' : jlongArray, 
                'type' : p.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned long *OUTPUT, 
                'code' : long[], 
                'type' : p.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned long *OUTPUT, 
                'code' : $javainput, 
                'type' : p.unsigned long, 
            }
, 
        }
, 
    }
, 
    'r.unsigned long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned long &INOUT, 
                'code' : , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned long &INOUT, 
                'code' : long[], 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned long &INOUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned long *INOUT directorin typemap, unsigned long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned long &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned long &INOUT, 
                'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); }, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned long &INOUT, 
                'code' : $javacall, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned long &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0); 
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned long &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1055, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned long &INOUT, 
                'code' : , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned long &INOUT, 
                'code' : jlongArray, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned long &INOUT, 
                'code' : long[], 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned long &INOUT, 
                'code' : $javainput, 
                'type' : r.unsigned long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned long &INPUT, 
                'code' : , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned long &INPUT, 
                'code' : long, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned long &INPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : J, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned long &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jlong *) &$1; , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned long &INPUT, 
                'code' : $javacall, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned long &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned long &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned long &INPUT, 
                'code' : jlong, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned long &INPUT, 
                'code' : long, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned long &INPUT, 
                'code' : $javainput, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 55, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned long &INPUT, 
                'code' : , 
                'type' : r.unsigned long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned long &OUTPUT, 
                'code' : , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned long &OUTPUT, 
                'code' : long[], 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned long &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Long;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned long &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.unsigned long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned long &OUTPUT, 
                'code' : {
  jlong jvalue = (jlong)temp$argnum;
  jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned long &OUTPUT, 
                'code' : $javacall, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned long &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned long &OUTPUT, 
                'code' : {
}, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned long &OUTPUT, 
                'code' : jlongArray, 
                'type' : r.unsigned long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned long &OUTPUT, 
                'code' : long[], 
                'type' : r.unsigned long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned long &OUTPUT, 
                'code' : $javainput, 
                'type' : r.unsigned long, 
            }
, 
        }
, 
    }
, 
    'a(ANY).unsigned long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned long [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long [ANY], 
            'code' : long[], 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned long [ANY], 
            'code' :  SWIG_JavaArrayArgoutUlong(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInUlong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long [ANY], 
            'code' : jlongArray, 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long [ANY], 
            'code' : long[], 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long [ANY], 
            'code' : $result = SWIG_JavaArrayOutUlong(jenv, $1, $1_dim0); , 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long [ANY], 
            'code' : , 
            'type' : a(ANY).unsigned long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).unsigned long, 
        }
, 
    }
, 
    'a().unsigned long' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned long [], 
            'code' :  delete [] $1; , 
            'type' : a().unsigned long, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned long [], 
            'code' : long[], 
            'type' : a().unsigned long, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned long [], 
            'code' :  SWIG_JavaArrayArgoutUlong(jenv, jarr$argnum, $1, $input); , 
            'type' : a().unsigned long, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jlong, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned long [], 
            'code' :   if (!SWIG_JavaArrayInUlong(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().unsigned long, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned long [], 
            'code' : jlongArray, 
            'type' : a().unsigned long, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned long [], 
            'code' : long[], 
            'type' : a().unsigned long, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned long [], 
            'code' : $result = SWIG_JavaArrayOutUlong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().unsigned long, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned long [], 
            'code' : $javainput, 
            'type' : a().unsigned long, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1055, 
            }
, 
            'typemap' : typemap(typecheck) unsigned long [], 
            'code' : , 
            'type' : a().unsigned long, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned long [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().unsigned long, 
        }
, 
    }
, 
    'jbyte' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jbyte, 
            'code' : byte, 
            'type' : jbyte, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : B, 
            }
, 
            'typemap' : typemap(directorin) jbyte, 
            'code' : $input = $1;, 
            'type' : jbyte, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jbyte, 
            'code' : $jniinput, 
            'type' : jbyte, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jbyte, 
            'code' :  $1 = $input; , 
            'type' : jbyte, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jbyte, 
            'code' :  $result = $input; , 
            'type' : jbyte, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jbyte, 
            'code' : $javacall, 
            'type' : jbyte, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jbyte, 
            'code' : jbyte, 
            'type' : jbyte, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jbyte, 
            'code' : byte, 
            'type' : jbyte, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jbyte, 
            'code' :  $result = $1; , 
            'type' : jbyte, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 25, 
            }
, 
            'typemap' : typemap(typecheck) jbyte, 
            'code' : , 
            'type' : jbyte, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jbyte, 
            'code' : $javainput, 
            'type' : jbyte, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jbyte, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jbyte, 
        }
, 
    }
, 
    'p.char' : Hash {
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 140, 
            }
, 
            'typemap' : typemap(typecheck) char *, 
            'code' : , 
            'type' : p.char, 
        }
, 
        'tmap:memberin' : Hash {
            'typemap' : typemap(memberin) char *, 
            'code' : {
  if ($1) delete [] $1;
  if ($input) {
     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
     strcpy((char *)$1, (const char *)$input);
  } else {
     $1 = 0;
  }
}, 
            'type' : p.char, 
        }
, 
        'tmap:newfree' : Hash {
            'typemap' : typemap(newfree) char *, 
            'code' : delete [] $1;, 
            'type' : p.char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) char *, 
            'code' : String, 
            'type' : p.char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) char *, 
            'code' : $jniinput, 
            'type' : p.char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Ljava/lang/String;, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(directorin) char *, 
            'code' : $input = 0;
  if ($1) {
    $input = jenv->NewStringUTF((const char *)$1);
    if (!$input) return $null;
  }, 
            'type' : p.char, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) char *, 
            'code' :  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
   return $null; , 
            'type' : p.char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) char *, 
            'code' : $javacall, 
            'type' : p.char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
                'nextSibling' : Hash {
                    'name' : warning, 
                    'value' : 473:Returning a pointer or reference in a director method is not recommended., 
                }
, 
            }
, 
            'typemap' : typemap(directorout) char *, 
            'code' : $1 = 0;
  if ($input) {
    $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$result) return $null;
  }, 
            'type' : p.char, 
        }
, 
        'tmap:out' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(out) char *, 
            'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);, 
            'type' : p.char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) char *, 
            'code' : jstring, 
            'type' : p.char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) char *, 
            'code' : {
    return $jnicall;
  }, 
            'type' : p.char, 
        }
, 
        'tmap:globalin' : Hash {
            'typemap' : typemap(globalin) char *, 
            'code' : {
  if ($1) delete [] $1;
  if ($input) {
     $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
     strcpy((char *)$1, (const char *)$input);
  } else {
     $1 = 0;
  }
}, 
            'type' : p.char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
                'nextSibling' : Hash {
                    'name' : noblock, 
                    'value' : 1, 
                }
, 
            }
, 
            'typemap' : typemap(in) char *, 
            'code' : $1 = 0;
  if ($input) {
    $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
    if (!$1) return $null;
  }, 
            'type' : p.char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) char *, 
            'code' : $javainput, 
            'type' : p.char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) char *, 
            'code' : String, 
            'type' : p.char, 
        }
, 
        'tmap:freearg' : Hash {
            'kwargs' : Hash {
                'name' : noblock, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(freearg) char *, 
            'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);, 
            'type' : p.char, 
        }
, 
    }
, 
    'r.unsigned char' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned char &INOUT, 
                'code' : , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned char &INOUT, 
                'code' : short[], 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned char &INOUT, 
                'code' : $jniinput, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned char *INOUT directorin typemap, unsigned char array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned char &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned char &INOUT, 
                'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); }, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned char &INOUT, 
                'code' : $javacall, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned char &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0); 
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned char *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned char &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1035, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned char &INOUT, 
                'code' : , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned char &INOUT, 
                'code' : jshortArray, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned char &INOUT, 
                'code' : short[], 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned char &INOUT, 
                'code' : $javainput, 
                'type' : r.unsigned char, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned char &INPUT, 
                'code' : , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned char &INPUT, 
                'code' : short, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned char &INPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : S, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned char &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jshort *) &$1; , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned char &INPUT, 
                'code' : $javacall, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned char &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned char &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned char &INPUT, 
                'code' : jshort, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned char &INPUT, 
                'code' : short, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned char &INPUT, 
                'code' : $javainput, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 35, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned char &INPUT, 
                'code' : , 
                'type' : r.unsigned char, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned char &OUTPUT, 
                'code' : , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned char &OUTPUT, 
                'code' : short[], 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned char &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned char &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.unsigned char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned char &OUTPUT, 
                'code' : {
  jshort jvalue = (jshort)temp$argnum;
  jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned char &OUTPUT, 
                'code' : $javacall, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned char &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned char *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned char &OUTPUT, 
                'code' : {
}, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned char &OUTPUT, 
                'code' : jshortArray, 
                'type' : r.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned char &OUTPUT, 
                'code' : short[], 
                'type' : r.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned char &OUTPUT, 
                'code' : $javainput, 
                'type' : r.unsigned char, 
            }
, 
        }
, 
    }
, 
    'p.unsigned char' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned char *INOUT, 
                'code' : , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned char *INOUT, 
                'code' : short[], 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned char *INOUT, 
                'code' : $jniinput, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned char *INOUT directorin typemap, unsigned char array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned char *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned char *INOUT, 
                'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); }, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned char *INOUT, 
                'code' : $javacall, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned char *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0); 
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned char *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned char *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1035, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned char *INOUT, 
                'code' : , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned char *INOUT, 
                'code' : jshortArray, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned char *INOUT, 
                'code' : short[], 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned char *INOUT, 
                'code' : $javainput, 
                'type' : p.unsigned char, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned char *INPUT, 
                'code' : , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned char *INPUT, 
                'code' : short, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned char *INPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : S, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned char *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jshort *) $1; , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned char *INPUT, 
                'code' : $javacall, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned char *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned char *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned char *INPUT, 
                'code' : jshort, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned char *INPUT, 
                'code' : short, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned char *INPUT, 
                'code' : $javainput, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 35, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned char *INPUT, 
                'code' : , 
                'type' : p.unsigned char, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned char *OUTPUT, 
                'code' : , 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned char *OUTPUT, 
                'code' : short[], 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned char *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned char *OUTPUT directorin typemap, unsigned char array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned char *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned char *OUTPUT, 
                'code' : {
  jshort jvalue = (jshort)temp$argnum;
  jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned char *OUTPUT, 
                'code' : $javacall, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned char *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned char *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned char *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned char *OUTPUT, 
                'code' : jshortArray, 
                'type' : p.unsigned char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned char *OUTPUT, 
                'code' : short[], 
                'type' : p.unsigned char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned char *OUTPUT, 
                'code' : $javainput, 
                'type' : p.unsigned char, 
            }
, 
        }
, 
    }
, 
    'r.signed char' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) signed char &INOUT, 
                'code' : , 
                'type' : r.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) signed char &INOUT, 
                'code' : byte[], 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) signed char &INOUT, 
                'code' : $jniinput, 
                'type' : r.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Byte;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide signed char *INOUT directorin typemap, signed char array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) signed char &INOUT, 
                'code' : {
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) signed char &INOUT, 
                'code' : { jenv->ReleaseByteArrayElements($input, (jbyte *)$1, 0); }, 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) signed char &INOUT, 
                'code' : $javacall, 
                'type' : r.signed char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) signed char &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetByteArrayElements($input, 0); 
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide signed char *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) signed char &INOUT, 
                'code' : {
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1025, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) signed char &INOUT, 
                'code' : , 
                'type' : r.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) signed char &INOUT, 
                'code' : jbyteArray, 
                'type' : r.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) signed char &INOUT, 
                'code' : byte[], 
                'type' : r.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) signed char &INOUT, 
                'code' : $javainput, 
                'type' : r.signed char, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) signed char &INPUT, 
                'code' : , 
                'type' : r.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) signed char &INPUT, 
                'code' : byte, 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) signed char &INPUT, 
                'code' : $jniinput, 
                'type' : r.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : B, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) signed char &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jbyte *) &$1; , 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) signed char &INPUT, 
                'code' : $javacall, 
                'type' : r.signed char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) signed char &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) signed char &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) signed char &INPUT, 
                'code' : jbyte, 
                'type' : r.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) signed char &INPUT, 
                'code' : byte, 
                'type' : r.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) signed char &INPUT, 
                'code' : $javainput, 
                'type' : r.signed char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 25, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) signed char &INPUT, 
                'code' : , 
                'type' : r.signed char, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) signed char &OUTPUT, 
                'code' : , 
                'type' : r.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) signed char &OUTPUT, 
                'code' : byte[], 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) signed char &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Byte;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) signed char &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.signed char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) signed char &OUTPUT, 
                'code' : {
  jbyte jvalue = (jbyte)temp$argnum;
  jenv->SetByteArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) signed char &OUTPUT, 
                'code' : $javacall, 
                'type' : r.signed char, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) signed char &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide signed char *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) signed char &OUTPUT, 
                'code' : {
}, 
                'type' : r.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) signed char &OUTPUT, 
                'code' : jbyteArray, 
                'type' : r.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) signed char &OUTPUT, 
                'code' : byte[], 
                'type' : r.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) signed char &OUTPUT, 
                'code' : $javainput, 
                'type' : r.signed char, 
            }
, 
        }
, 
    }
, 
    'p.signed char' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) signed char *INOUT, 
                'code' : , 
                'type' : p.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) signed char *INOUT, 
                'code' : byte[], 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) signed char *INOUT, 
                'code' : $jniinput, 
                'type' : p.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Byte;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide signed char *INOUT directorin typemap, signed char array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) signed char *INOUT, 
                'code' : {
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) signed char *INOUT, 
                'code' : { jenv->ReleaseByteArrayElements($input, (jbyte *)$1, 0); }, 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) signed char *INOUT, 
                'code' : $javacall, 
                'type' : p.signed char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) signed char *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetByteArrayElements($input, 0); 
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide signed char *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) signed char *INOUT, 
                'code' : {
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1025, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) signed char *INOUT, 
                'code' : , 
                'type' : p.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) signed char *INOUT, 
                'code' : jbyteArray, 
                'type' : p.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) signed char *INOUT, 
                'code' : byte[], 
                'type' : p.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) signed char *INOUT, 
                'code' : $javainput, 
                'type' : p.signed char, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) signed char *INPUT, 
                'code' : , 
                'type' : p.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) signed char *INPUT, 
                'code' : byte, 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) signed char *INPUT, 
                'code' : $jniinput, 
                'type' : p.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : B, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) signed char *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jbyte *) $1; , 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) signed char *INPUT, 
                'code' : $javacall, 
                'type' : p.signed char, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) signed char *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) signed char *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) signed char *INPUT, 
                'code' : jbyte, 
                'type' : p.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) signed char *INPUT, 
                'code' : byte, 
                'type' : p.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) signed char *INPUT, 
                'code' : $javainput, 
                'type' : p.signed char, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 25, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) signed char *INPUT, 
                'code' : , 
                'type' : p.signed char, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) signed char *OUTPUT, 
                'code' : , 
                'type' : p.signed char, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) signed char *OUTPUT, 
                'code' : byte[], 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) signed char *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.signed char, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Byte;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide signed char *OUTPUT directorin typemap, signed char array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) signed char *OUTPUT, 
                'code' : {
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) signed char *OUTPUT, 
                'code' : {
  jbyte jvalue = (jbyte)temp$argnum;
  jenv->SetByteArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) signed char *OUTPUT, 
                'code' : $javacall, 
                'type' : p.signed char, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) signed char *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide signed char *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) signed char *OUTPUT, 
                'code' : {
}, 
                'type' : p.signed char, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) signed char *OUTPUT, 
                'code' : jbyteArray, 
                'type' : p.signed char, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) signed char *OUTPUT, 
                'code' : byte[], 
                'type' : p.signed char, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) signed char *OUTPUT, 
                'code' : $javainput, 
                'type' : p.signed char, 
            }
, 
        }
, 
    }
, 
    'r.q(const).signed char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) signed char const &, 
            'code' : byte, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : B, 
            }
, 
            'typemap' : typemap(directorin) signed char const &, 
            'code' : $input = (jbyte)$1_name;, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) signed char const &, 
            'code' : $jniinput, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) signed char const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) signed char const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) signed char const &, 
            'code' : $javacall, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) signed char const &, 
            'code' : jbyte, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) signed char const &, 
            'code' : byte, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) signed char const &, 
            'code' :  $result = (jbyte)*$1; , 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 25, 
            }
, 
            'typemap' : typemap(typecheck) signed char const &, 
            'code' : , 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) signed char const &, 
            'code' : $javainput, 
            'type' : r.q(const).signed char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) signed char const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).signed char, 
        }
, 
    }
, 
    'signed char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) signed char, 
            'code' : byte, 
            'type' : signed char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : B, 
            }
, 
            'typemap' : typemap(directorin) signed char, 
            'code' : $input = (jbyte) $1;, 
            'type' : signed char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) signed char, 
            'code' : $jniinput, 
            'type' : signed char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) signed char, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : signed char, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) signed char, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : signed char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) signed char, 
            'code' : $javacall, 
            'type' : signed char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) signed char, 
            'code' : jbyte, 
            'type' : signed char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) signed char, 
            'code' : byte, 
            'type' : signed char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) signed char, 
            'code' :  $result = (jbyte)$1; , 
            'type' : signed char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 25, 
            }
, 
            'typemap' : typemap(typecheck) signed char, 
            'code' : , 
            'type' : signed char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) signed char, 
            'code' : $javainput, 
            'type' : signed char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) signed char, 
            'code' : {
    return $jnicall;
  }, 
            'type' : signed char, 
        }
, 
    }
, 
    'unsigned char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned char, 
            'code' : short, 
            'type' : unsigned char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : S, 
            }
, 
            'typemap' : typemap(directorin) unsigned char, 
            'code' : $input = (jshort) $1;, 
            'type' : unsigned char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned char, 
            'code' : $jniinput, 
            'type' : unsigned char, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned char, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : unsigned char, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) unsigned char, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : unsigned char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned char, 
            'code' : $javacall, 
            'type' : unsigned char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned char, 
            'code' : jshort, 
            'type' : unsigned char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned char, 
            'code' : short, 
            'type' : unsigned char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned char, 
            'code' :  $result = (jshort)$1; , 
            'type' : unsigned char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 35, 
            }
, 
            'typemap' : typemap(typecheck) unsigned char, 
            'code' : , 
            'type' : unsigned char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned char, 
            'code' : $javainput, 
            'type' : unsigned char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned char, 
            'code' : {
    return $jnicall;
  }, 
            'type' : unsigned char, 
        }
, 
    }
, 
    'r.q(const).unsigned char' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned char const &, 
            'code' : short, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : S, 
            }
, 
            'typemap' : typemap(directorin) unsigned char const &, 
            'code' : $input = (jshort)$1_name;, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) unsigned char const &, 
            'code' : $jniinput, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned char const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) unsigned char const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) unsigned char const &, 
            'code' : $javacall, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned char const &, 
            'code' : jshort, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned char const &, 
            'code' : short, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned char const &, 
            'code' :  $result = (jshort)*$1; , 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 35, 
            }
, 
            'typemap' : typemap(typecheck) unsigned char const &, 
            'code' : , 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned char const &, 
            'code' : $javainput, 
            'type' : r.q(const).unsigned char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned char const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).unsigned char, 
        }
, 
    }
, 
    'a(ANY).signed char' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) signed char [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) signed char [ANY], 
            'code' : byte[], 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) signed char [ANY], 
            'code' :  SWIG_JavaArrayArgoutSchar(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jbyte, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) signed char [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInSchar(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) signed char [ANY], 
            'code' : jbyteArray, 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) signed char [ANY], 
            'code' : byte[], 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) signed char [ANY], 
            'code' : $result = SWIG_JavaArrayOutSchar(jenv, $1, $1_dim0); , 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) signed char [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1025, 
            }
, 
            'typemap' : typemap(typecheck) signed char [ANY], 
            'code' : , 
            'type' : a(ANY).signed char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) signed char [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).signed char, 
        }
, 
    }
, 
    'a().signed char' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) signed char [], 
            'code' :  delete [] $1; , 
            'type' : a().signed char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) signed char [], 
            'code' : byte[], 
            'type' : a().signed char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) signed char [], 
            'code' :  SWIG_JavaArrayArgoutSchar(jenv, jarr$argnum, $1, $input); , 
            'type' : a().signed char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jbyte, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) signed char [], 
            'code' :   if (!SWIG_JavaArrayInSchar(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().signed char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) signed char [], 
            'code' : jbyteArray, 
            'type' : a().signed char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) signed char [], 
            'code' : byte[], 
            'type' : a().signed char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) signed char [], 
            'code' : $result = SWIG_JavaArrayOutSchar(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().signed char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) signed char [], 
            'code' : $javainput, 
            'type' : a().signed char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1025, 
            }
, 
            'typemap' : typemap(typecheck) signed char [], 
            'code' : , 
            'type' : a().signed char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) signed char [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().signed char, 
        }
, 
    }
, 
    'a(ANY).unsigned char' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned char [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned char [ANY], 
            'code' : short[], 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned char [ANY], 
            'code' :  SWIG_JavaArrayArgoutUchar(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jshort, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned char [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInUchar(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned char [ANY], 
            'code' : jshortArray, 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned char [ANY], 
            'code' : short[], 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned char [ANY], 
            'code' : $result = SWIG_JavaArrayOutUchar(jenv, $1, $1_dim0); , 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned char [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1035, 
            }
, 
            'typemap' : typemap(typecheck) unsigned char [ANY], 
            'code' : , 
            'type' : a(ANY).unsigned char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned char [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).unsigned char, 
        }
, 
    }
, 
    'a().unsigned char' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned char [], 
            'code' :  delete [] $1; , 
            'type' : a().unsigned char, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned char [], 
            'code' : short[], 
            'type' : a().unsigned char, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned char [], 
            'code' :  SWIG_JavaArrayArgoutUchar(jenv, jarr$argnum, $1, $input); , 
            'type' : a().unsigned char, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jshort, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned char [], 
            'code' :   if (!SWIG_JavaArrayInUchar(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().unsigned char, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned char [], 
            'code' : jshortArray, 
            'type' : a().unsigned char, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned char [], 
            'code' : short[], 
            'type' : a().unsigned char, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned char [], 
            'code' : $result = SWIG_JavaArrayOutUchar(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().unsigned char, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned char [], 
            'code' : $javainput, 
            'type' : a().unsigned char, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1035, 
            }
, 
            'typemap' : typemap(typecheck) unsigned char [], 
            'code' : , 
            'type' : a().unsigned char, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned char [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().unsigned char, 
        }
, 
    }
, 
    'r.q(const).int' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) int const &, 
            'code' : int, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) int const &, 
            'code' : $input = (jint)$1_name;, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) int const &, 
            'code' : $jniinput, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) int const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).int, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) int const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).int, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) int const &, 
            'code' : $javacall, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) int const &, 
            'code' : jint, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) int const &, 
            'code' : int, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) int const &, 
            'code' :  $result = (jint)*$1; , 
            'type' : r.q(const).int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) int const &, 
            'code' : , 
            'type' : r.q(const).int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) int const &, 
            'code' : $javainput, 
            'type' : r.q(const).int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) int const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).int, 
        }
, 
    }
, 
    'r.q(const).bool' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) bool const &, 
            'code' : boolean, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) bool const &, 
            'code' : $jniinput, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : Z, 
            }
, 
            'typemap' : typemap(directorin) bool const &, 
            'code' : $input = (jboolean)$1_name;, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) bool const &, 
            'code' :  temp = $input ? true : false; 
   $1 = &temp; , 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) bool const &, 
            'code' :  static $*1_ltype temp;
   temp = $input ? true : false; 
   $result = &temp; , 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) bool const &, 
            'code' : $javacall, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) bool const &, 
            'code' : jboolean, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) bool const &, 
            'code' : boolean, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) bool const &, 
            'code' :  $result = (jboolean)*$1; , 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 15, 
            }
, 
            'typemap' : typemap(typecheck) bool const &, 
            'code' : , 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) bool const &, 
            'code' : $javainput, 
            'type' : r.q(const).bool, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) bool const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).bool, 
        }
, 
    }
, 
    'a().bool' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) bool [], 
            'code' :  delete [] $1; , 
            'type' : a().bool, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) bool [], 
            'code' : boolean[], 
            'type' : a().bool, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) bool [], 
            'code' :  SWIG_JavaArrayArgoutBool(jenv, jarr$argnum, $1, $input); , 
            'type' : a().bool, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jboolean, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) bool [], 
            'code' :   if (!SWIG_JavaArrayInBool(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().bool, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) bool [], 
            'code' : jbooleanArray, 
            'type' : a().bool, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) bool [], 
            'code' : boolean[], 
            'type' : a().bool, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) bool [], 
            'code' : $result = SWIG_JavaArrayOutBool(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().bool, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) bool [], 
            'code' : $javainput, 
            'type' : a().bool, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1015, 
            }
, 
            'typemap' : typemap(typecheck) bool [], 
            'code' : , 
            'type' : a().bool, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) bool [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().bool, 
        }
, 
    }
, 
    'r.q(const).size_t' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) size_t const &, 
            'code' : long, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) size_t const &, 
            'code' : $input = (jlong)$1_name;, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) size_t const &, 
            'code' : $jniinput, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) size_t const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) size_t const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) size_t const &, 
            'code' : $javacall, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) size_t const &, 
            'code' : jlong, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) size_t const &, 
            'code' : long, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) size_t const &, 
            'code' :  $result = (jlong)*$1; , 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) size_t const &, 
            'code' : , 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) size_t const &, 
            'code' : $javainput, 
            'type' : r.q(const).size_t, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) size_t const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).size_t, 
        }
, 
    }
, 
    'size_t' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) size_t, 
            'code' : long, 
            'type' : size_t, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : J, 
            }
, 
            'typemap' : typemap(directorin) size_t, 
            'code' : $input = (jlong) $1;, 
            'type' : size_t, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) size_t, 
            'code' : $jniinput, 
            'type' : size_t, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) size_t, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : size_t, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) size_t, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : size_t, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) size_t, 
            'code' : $javacall, 
            'type' : size_t, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) size_t, 
            'code' : jlong, 
            'type' : size_t, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) size_t, 
            'code' : long, 
            'type' : size_t, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) size_t, 
            'code' :  $result = (jlong)$1; , 
            'type' : size_t, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 55, 
            }
, 
            'typemap' : typemap(typecheck) size_t, 
            'code' : , 
            'type' : size_t, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) size_t, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : size_t, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) size_t, 
            'code' : $javainput, 
            'type' : size_t, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) size_t, 
            'code' : {
    return $jnicall;
  }, 
            'type' : size_t, 
        }
, 
    }
, 
    'p.unsigned short' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned short *INOUT, 
                'code' : , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned short *INOUT, 
                'code' : int[], 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned short *INOUT, 
                'code' : $jniinput, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned short *INOUT directorin typemap, unsigned short array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned short *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned short *INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned short *INOUT, 
                'code' : $javacall, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned short *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned short *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned short *INOUT, 
                'code' : {
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned short *INOUT, 
                'code' : , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned short *INOUT, 
                'code' : jintArray, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned short *INOUT, 
                'code' : int[], 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned short *INOUT, 
                'code' : $javainput, 
                'type' : p.unsigned short, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned short *INPUT, 
                'code' : , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned short *INPUT, 
                'code' : int, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned short *INPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned short *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) $1; , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned short *INPUT, 
                'code' : $javacall, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned short *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned short *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned short *INPUT, 
                'code' : jint, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned short *INPUT, 
                'code' : int, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned short *INPUT, 
                'code' : $javainput, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned short *INPUT, 
                'code' : , 
                'type' : p.unsigned short, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned short *OUTPUT, 
                'code' : , 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned short *OUTPUT, 
                'code' : int[], 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned short *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned short *OUTPUT directorin typemap, unsigned short array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned short *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned short *OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned short *OUTPUT, 
                'code' : $javacall, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned short *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned short *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned short *OUTPUT, 
                'code' : {
}, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned short *OUTPUT, 
                'code' : jintArray, 
                'type' : p.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned short *OUTPUT, 
                'code' : int[], 
                'type' : p.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned short *OUTPUT, 
                'code' : $javainput, 
                'type' : p.unsigned short, 
            }
, 
        }
, 
    }
, 
    'unsigned short' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned short, 
            'code' : int, 
            'type' : unsigned short, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) unsigned short, 
            'code' : $input = (jint) $1;, 
            'type' : unsigned short, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) unsigned short, 
            'code' : $jniinput, 
            'type' : unsigned short, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned short, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : unsigned short, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) unsigned short, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : unsigned short, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) unsigned short, 
            'code' : $javacall, 
            'type' : unsigned short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned short, 
            'code' : jint, 
            'type' : unsigned short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned short, 
            'code' : int, 
            'type' : unsigned short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned short, 
            'code' :  $result = (jint)$1; , 
            'type' : unsigned short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) unsigned short, 
            'code' : , 
            'type' : unsigned short, 
        }
, 
        'tmap:throws' : Hash {
            'typemap' : typemap(throws) unsigned short, 
            'code' :  char error_msg[256];
   sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
   SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
   return $null; , 
            'type' : unsigned short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned short, 
            'code' : $javainput, 
            'type' : unsigned short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned short, 
            'code' : {
    return $jnicall;
  }, 
            'type' : unsigned short, 
        }
, 
    }
, 
    'r.q(const).unsigned short' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned short const &, 
            'code' : int, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : I, 
            }
, 
            'typemap' : typemap(directorin) unsigned short const &, 
            'code' : $input = (jint)$1_name;, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) unsigned short const &, 
            'code' : $jniinput, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned short const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) unsigned short const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) unsigned short const &, 
            'code' : $javacall, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned short const &, 
            'code' : jint, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned short const &, 
            'code' : int, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned short const &, 
            'code' :  $result = (jint)*$1; , 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 45, 
            }
, 
            'typemap' : typemap(typecheck) unsigned short const &, 
            'code' : , 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned short const &, 
            'code' : $javainput, 
            'type' : r.q(const).unsigned short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned short const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).unsigned short, 
        }
, 
    }
, 
    'r.unsigned short' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) unsigned short &INOUT, 
                'code' : , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) unsigned short &INOUT, 
                'code' : int[], 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) unsigned short &INOUT, 
                'code' : $jniinput, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide unsigned short *INOUT directorin typemap, unsigned short array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) unsigned short &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) unsigned short &INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) unsigned short &INOUT, 
                'code' : $javacall, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) unsigned short &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned short *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) unsigned short &INOUT, 
                'code' : {
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) unsigned short &INOUT, 
                'code' : , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) unsigned short &INOUT, 
                'code' : jintArray, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) unsigned short &INOUT, 
                'code' : int[], 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) unsigned short &INOUT, 
                'code' : $javainput, 
                'type' : r.unsigned short, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) unsigned short &INPUT, 
                'code' : , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) unsigned short &INPUT, 
                'code' : int, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) unsigned short &INPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) unsigned short &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) &$1; , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) unsigned short &INPUT, 
                'code' : $javacall, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) unsigned short &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) unsigned short &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) unsigned short &INPUT, 
                'code' : jint, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) unsigned short &INPUT, 
                'code' : int, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) unsigned short &INPUT, 
                'code' : $javainput, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) unsigned short &INPUT, 
                'code' : , 
                'type' : r.unsigned short, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) unsigned short &OUTPUT, 
                'code' : , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) unsigned short &OUTPUT, 
                'code' : int[], 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) unsigned short &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) unsigned short &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.unsigned short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) unsigned short &OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) unsigned short &OUTPUT, 
                'code' : $javacall, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) unsigned short &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide unsigned short *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) unsigned short &OUTPUT, 
                'code' : {
}, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) unsigned short &OUTPUT, 
                'code' : jintArray, 
                'type' : r.unsigned short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) unsigned short &OUTPUT, 
                'code' : int[], 
                'type' : r.unsigned short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) unsigned short &OUTPUT, 
                'code' : $javainput, 
                'type' : r.unsigned short, 
            }
, 
        }
, 
    }
, 
    'a(ANY).unsigned short' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned short [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned short [ANY], 
            'code' : int[], 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned short [ANY], 
            'code' :  SWIG_JavaArrayArgoutUshort(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned short [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInUshort(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned short [ANY], 
            'code' : jintArray, 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned short [ANY], 
            'code' : int[], 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned short [ANY], 
            'code' : $result = SWIG_JavaArrayOutUshort(jenv, $1, $1_dim0); , 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned short [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) unsigned short [ANY], 
            'code' : , 
            'type' : a(ANY).unsigned short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned short [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).unsigned short, 
        }
, 
    }
, 
    'a().unsigned short' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) unsigned short [], 
            'code' :  delete [] $1; , 
            'type' : a().unsigned short, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) unsigned short [], 
            'code' : int[], 
            'type' : a().unsigned short, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) unsigned short [], 
            'code' :  SWIG_JavaArrayArgoutUshort(jenv, jarr$argnum, $1, $input); , 
            'type' : a().unsigned short, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) unsigned short [], 
            'code' :   if (!SWIG_JavaArrayInUshort(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().unsigned short, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) unsigned short [], 
            'code' : jintArray, 
            'type' : a().unsigned short, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) unsigned short [], 
            'code' : int[], 
            'type' : a().unsigned short, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) unsigned short [], 
            'code' : $result = SWIG_JavaArrayOutUshort(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().unsigned short, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) unsigned short [], 
            'code' : $javainput, 
            'type' : a().unsigned short, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) unsigned short [], 
            'code' : , 
            'type' : a().unsigned short, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) unsigned short [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().unsigned short, 
        }
, 
    }
, 
    'r.short' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) short &INOUT, 
                'code' : , 
                'type' : r.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) short &INOUT, 
                'code' : short[], 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) short &INOUT, 
                'code' : $jniinput, 
                'type' : r.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide short *INOUT directorin typemap, short array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) short &INOUT, 
                'code' : {
}, 
                'type' : r.short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) short &INOUT, 
                'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); }, 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) short &INOUT, 
                'code' : $javacall, 
                'type' : r.short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) short &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0); 
}, 
                'type' : r.short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide short *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) short &INOUT, 
                'code' : {
}, 
                'type' : r.short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1035, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) short &INOUT, 
                'code' : , 
                'type' : r.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) short &INOUT, 
                'code' : jshortArray, 
                'type' : r.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) short &INOUT, 
                'code' : short[], 
                'type' : r.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) short &INOUT, 
                'code' : $javainput, 
                'type' : r.short, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) short &INPUT, 
                'code' : , 
                'type' : r.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) short &INPUT, 
                'code' : short, 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) short &INPUT, 
                'code' : $jniinput, 
                'type' : r.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : S, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) short &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jshort *) &$1; , 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) short &INPUT, 
                'code' : $javacall, 
                'type' : r.short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) short &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.short, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) short &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) short &INPUT, 
                'code' : jshort, 
                'type' : r.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) short &INPUT, 
                'code' : short, 
                'type' : r.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) short &INPUT, 
                'code' : $javainput, 
                'type' : r.short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 35, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) short &INPUT, 
                'code' : , 
                'type' : r.short, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) short &OUTPUT, 
                'code' : , 
                'type' : r.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) short &OUTPUT, 
                'code' : short[], 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) short &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) short &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) short &OUTPUT, 
                'code' : {
  jshort jvalue = (jshort)temp$argnum;
  jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) short &OUTPUT, 
                'code' : $javacall, 
                'type' : r.short, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) short &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide short *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) short &OUTPUT, 
                'code' : {
}, 
                'type' : r.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) short &OUTPUT, 
                'code' : jshortArray, 
                'type' : r.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) short &OUTPUT, 
                'code' : short[], 
                'type' : r.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) short &OUTPUT, 
                'code' : $javainput, 
                'type' : r.short, 
            }
, 
        }
, 
    }
, 
    'p.short' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) short *INOUT, 
                'code' : , 
                'type' : p.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) short *INOUT, 
                'code' : short[], 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) short *INOUT, 
                'code' : $jniinput, 
                'type' : p.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide short *INOUT directorin typemap, short array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) short *INOUT, 
                'code' : {
}, 
                'type' : p.short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) short *INOUT, 
                'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); }, 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) short *INOUT, 
                'code' : $javacall, 
                'type' : p.short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) short *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0); 
}, 
                'type' : p.short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide short *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) short *INOUT, 
                'code' : {
}, 
                'type' : p.short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1035, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) short *INOUT, 
                'code' : , 
                'type' : p.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) short *INOUT, 
                'code' : jshortArray, 
                'type' : p.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) short *INOUT, 
                'code' : short[], 
                'type' : p.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) short *INOUT, 
                'code' : $javainput, 
                'type' : p.short, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) short *INPUT, 
                'code' : , 
                'type' : p.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) short *INPUT, 
                'code' : short, 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) short *INPUT, 
                'code' : $jniinput, 
                'type' : p.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : S, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) short *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jshort *) $1; , 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) short *INPUT, 
                'code' : $javacall, 
                'type' : p.short, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) short *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.short, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) short *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) short *INPUT, 
                'code' : jshort, 
                'type' : p.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) short *INPUT, 
                'code' : short, 
                'type' : p.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) short *INPUT, 
                'code' : $javainput, 
                'type' : p.short, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 35, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) short *INPUT, 
                'code' : , 
                'type' : p.short, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) short *OUTPUT, 
                'code' : , 
                'type' : p.short, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) short *OUTPUT, 
                'code' : short[], 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) short *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.short, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Short;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide short *OUTPUT directorin typemap, short array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) short *OUTPUT, 
                'code' : {
}, 
                'type' : p.short, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) short *OUTPUT, 
                'code' : {
  jshort jvalue = (jshort)temp$argnum;
  jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.short, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) short *OUTPUT, 
                'code' : $javacall, 
                'type' : p.short, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) short *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.short, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide short *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) short *OUTPUT, 
                'code' : {
}, 
                'type' : p.short, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) short *OUTPUT, 
                'code' : jshortArray, 
                'type' : p.short, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) short *OUTPUT, 
                'code' : short[], 
                'type' : p.short, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) short *OUTPUT, 
                'code' : $javainput, 
                'type' : p.short, 
            }
, 
        }
, 
    }
, 
    'p.int' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) int *INOUT, 
                'code' : , 
                'type' : p.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) int *INOUT, 
                'code' : int[], 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) int *INOUT, 
                'code' : $jniinput, 
                'type' : p.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide int *INOUT directorin typemap, int array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) int *INOUT, 
                'code' : {
}, 
                'type' : p.int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) int *INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) int *INOUT, 
                'code' : $javacall, 
                'type' : p.int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) int *INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : p.int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide int *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) int *INOUT, 
                'code' : {
}, 
                'type' : p.int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) int *INOUT, 
                'code' : , 
                'type' : p.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) int *INOUT, 
                'code' : jintArray, 
                'type' : p.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) int *INOUT, 
                'code' : int[], 
                'type' : p.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) int *INOUT, 
                'code' : $javainput, 
                'type' : p.int, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) int *INPUT, 
                'code' : , 
                'type' : p.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) int *INPUT, 
                'code' : int, 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) int *INPUT, 
                'code' : $jniinput, 
                'type' : p.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) int *INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) $1; , 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) int *INPUT, 
                'code' : $javacall, 
                'type' : p.int, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) int *INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : p.int, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) int *INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : p.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) int *INPUT, 
                'code' : jint, 
                'type' : p.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) int *INPUT, 
                'code' : int, 
                'type' : p.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) int *INPUT, 
                'code' : $javainput, 
                'type' : p.int, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) int *INPUT, 
                'code' : , 
                'type' : p.int, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) int *OUTPUT, 
                'code' : , 
                'type' : p.int, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) int *OUTPUT, 
                'code' : int[], 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) int *OUTPUT, 
                'code' : $jniinput, 
                'type' : p.int, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide int *OUTPUT directorin typemap, int array length is unknown, 
                    }
, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) int *OUTPUT, 
                'code' : {
}, 
                'type' : p.int, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) int *OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : p.int, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) int *OUTPUT, 
                'code' : $javacall, 
                'type' : p.int, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) int *OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : p.int, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide int *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) int *OUTPUT, 
                'code' : {
}, 
                'type' : p.int, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) int *OUTPUT, 
                'code' : jintArray, 
                'type' : p.int, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) int *OUTPUT, 
                'code' : int[], 
                'type' : p.int, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) int *OUTPUT, 
                'code' : $javainput, 
                'type' : p.int, 
            }
, 
        }
, 
    }
, 
    'float' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) float, 
            'code' : float, 
            'type' : float, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : F, 
            }
, 
            'typemap' : typemap(directorin) float, 
            'code' : $input = (jfloat) $1;, 
            'type' : float, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) float, 
            'code' : $jniinput, 
            'type' : float, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) float, 
            'code' :  $1 = ($1_ltype)$input; , 
            'type' : float, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) float, 
            'code' :  $result = ($1_ltype)$input; , 
            'type' : float, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) float, 
            'code' : $javacall, 
            'type' : float, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) float, 
            'code' : jfloat, 
            'type' : float, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) float, 
            'code' : float, 
            'type' : float, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) float, 
            'code' :  $result = (jfloat)$1; , 
            'type' : float, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 80, 
            }
, 
            'typemap' : typemap(typecheck) float, 
            'code' : , 
            'type' : float, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) float, 
            'code' : $javainput, 
            'type' : float, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) float, 
            'code' : {
    return $jnicall;
  }, 
            'type' : float, 
        }
, 
    }
, 
    'r.long' : Hash {
        'INOUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(freearg) long &INOUT, 
                'code' : , 
                'type' : r.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jstype) long &INOUT, 
                'code' : int[], 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorin) long &INOUT, 
                'code' : $jniinput, 
                'type' : r.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                    'nextSibling' : Hash {
                        'name' : warning, 
                        'value' : Need to provide long *INOUT directorin typemap, long array length is unknown, 
                    }
, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorin) long &INOUT, 
                'code' : {
}, 
                'type' : r.long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(argout) long &INOUT, 
                'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); }, 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javadirectorout) long &INOUT, 
                'code' : $javacall, 
                'type' : r.long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(in) long &INOUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0); 
}, 
                'type' : r.long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long *INOUT directorout typemap, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(directorout) long &INOUT, 
                'code' : {
}, 
                'type' : r.long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 1045, 
                }
, 
                'pname' : INOUT, 
                'typemap' : typemap(typecheck) long &INOUT, 
                'code' : , 
                'type' : r.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jni) long &INOUT, 
                'code' : jintArray, 
                'type' : r.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(jtype) long &INOUT, 
                'code' : int[], 
                'type' : r.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INOUT, 
                'typemap' : typemap(javain) long &INOUT, 
                'code' : $javainput, 
                'type' : r.long, 
            }
, 
        }
, 
        'INPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(freearg) long &INPUT, 
                'code' : , 
                'type' : r.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jstype) long &INPUT, 
                'code' : int, 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorin) long &INPUT, 
                'code' : $jniinput, 
                'type' : r.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : I, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(directorin) long &INPUT, 
                'code' :  *(($&1_ltype) $input) = (jint *) &$1; , 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javadirectorout) long &INPUT, 
                'code' : $javacall, 
                'type' : r.long, 
            }
, 
            'tmap:in' : Hash {
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(in) long &INPUT, 
                'code' :  $1 = ($1_ltype)&$input; , 
                'type' : r.long, 
            }
, 
            'tmap:directorout' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(directorout) long &INPUT, 
                'code' :  $result = ($1_ltype)&$input; , 
                'type' : r.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jni) long &INPUT, 
                'code' : jint, 
                'type' : r.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(jtype) long &INPUT, 
                'code' : int, 
                'type' : r.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : INPUT, 
                'typemap' : typemap(javain) long &INPUT, 
                'code' : $javainput, 
                'type' : r.long, 
            }
, 
            'tmap:typecheck' : Hash {
                'kwargs' : Hash {
                    'name' : precedence, 
                    'value' : 45, 
                }
, 
                'pname' : INPUT, 
                'typemap' : typemap(typecheck) long &INPUT, 
                'code' : , 
                'type' : r.long, 
            }
, 
        }
, 
        'OUTPUT' : Hash {
            'tmap:freearg' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(freearg) long &OUTPUT, 
                'code' : , 
                'type' : r.long, 
            }
, 
            'tmap:jstype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jstype) long &OUTPUT, 
                'code' : int[], 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorin' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorin) long &OUTPUT, 
                'code' : $jniinput, 
                'type' : r.long, 
            }
, 
            'tmap:directorin' : Hash {
                'kwargs' : Hash {
                    'name' : descriptor, 
                    'value' : [Ljava/lang/Integer;, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorin) long &OUTPUT, 
                'code' :  *(($&1_ltype) $input = &$1; , 
                'type' : r.long, 
            }
, 
            'tmap:argout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(argout) long &OUTPUT, 
                'code' : {
  jint jvalue = (jint)temp$argnum;
  jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
}, 
                'type' : r.long, 
            }
, 
            'tmap:javadirectorout' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javadirectorout) long &OUTPUT, 
                'code' : $javacall, 
                'type' : r.long, 
            }
, 
            'tmap:in' : Hash {
                'locals' : Hash {
                    'name' : temp, 
                    'type' : $*1_ltype, 
                }
, 
                'kwargs' : Hash {
                    'name' : numinputs, 
                    'value' : 1, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(in) long &OUTPUT, 
                'code' : {
  if (!$input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
    return $null;
  }
  if (jenv->GetArrayLength($input) == 0) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
    return $null;
  }
  $1 = &temp; 
}, 
                'type' : r.long, 
            }
, 
            'tmap:directorout' : Hash {
                'kwargs' : Hash {
                    'name' : warning, 
                    'value' : Need to provide long *OUTPUT directorout typemap, 
                }
, 
                'pname' : OUTPUT, 
                'typemap' : typemap(directorout) long &OUTPUT, 
                'code' : {
}, 
                'type' : r.long, 
            }
, 
            'tmap:jni' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jni) long &OUTPUT, 
                'code' : jintArray, 
                'type' : r.long, 
            }
, 
            'tmap:jtype' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(jtype) long &OUTPUT, 
                'code' : int[], 
                'type' : r.long, 
            }
, 
            'tmap:javain' : Hash {
                'pname' : OUTPUT, 
                'typemap' : typemap(javain) long &OUTPUT, 
                'code' : $javainput, 
                'type' : r.long, 
            }
, 
        }
, 
    }
, 
    'jintArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jintArray, 
            'code' : int[], 
            'type' : jintArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [I, 
            }
, 
            'typemap' : typemap(directorin) jintArray, 
            'code' : $input = $1;, 
            'type' : jintArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jintArray, 
            'code' : $jniinput, 
            'type' : jintArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jintArray, 
            'code' :  $1 = $input; , 
            'type' : jintArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jintArray, 
            'code' :  $result = $input; , 
            'type' : jintArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jintArray, 
            'code' : $javacall, 
            'type' : jintArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jintArray, 
            'code' : jintArray, 
            'type' : jintArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jintArray, 
            'code' : int[], 
            'type' : jintArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jintArray, 
            'code' :  $result = $1; , 
            'type' : jintArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) jintArray, 
            'code' : , 
            'type' : jintArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jintArray, 
            'code' : $javainput, 
            'type' : jintArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jintArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jintArray, 
        }
, 
    }
, 
    'jshortArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jshortArray, 
            'code' : short[], 
            'type' : jshortArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [S, 
            }
, 
            'typemap' : typemap(directorin) jshortArray, 
            'code' : $input = $1;, 
            'type' : jshortArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jshortArray, 
            'code' : $jniinput, 
            'type' : jshortArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jshortArray, 
            'code' :  $1 = $input; , 
            'type' : jshortArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jshortArray, 
            'code' :  $result = $input; , 
            'type' : jshortArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jshortArray, 
            'code' : $javacall, 
            'type' : jshortArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jshortArray, 
            'code' : jshortArray, 
            'type' : jshortArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jshortArray, 
            'code' : short[], 
            'type' : jshortArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jshortArray, 
            'code' :  $result = $1; , 
            'type' : jshortArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1035, 
            }
, 
            'typemap' : typemap(typecheck) jshortArray, 
            'code' : , 
            'type' : jshortArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jshortArray, 
            'code' : $javainput, 
            'type' : jshortArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jshortArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jshortArray, 
        }
, 
    }
, 
    'a(ANY).int' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) int [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).int, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) int [ANY], 
            'code' : int[], 
            'type' : a(ANY).int, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) int [ANY], 
            'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) int [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInInt(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) int [ANY], 
            'code' : jintArray, 
            'type' : a(ANY).int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) int [ANY], 
            'code' : int[], 
            'type' : a(ANY).int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) int [ANY], 
            'code' : $result = SWIG_JavaArrayOutInt(jenv, $1, $1_dim0); , 
            'type' : a(ANY).int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) int [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) int [ANY], 
            'code' : , 
            'type' : a(ANY).int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) int [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).int, 
        }
, 
    }
, 
    'r.q(const).float' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) float const &, 
            'code' : float, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : F, 
            }
, 
            'typemap' : typemap(directorin) float const &, 
            'code' : $input = (jfloat)$1_name;, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorin) float const &, 
            'code' : $jniinput, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) float const &, 
            'code' :  temp = ($*1_ltype)$input; 
   $1 = &temp; , 
            'type' : r.q(const).float, 
        }
, 
        'tmap:directorout' : Hash {
            'kwargs' : Hash {
                'name' : warning, 
                'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead., 
            }
, 
            'typemap' : typemap(directorout) float const &, 
            'code' :  static $*1_ltype temp;
   temp = ($*1_ltype)$input; 
   $result = &temp; , 
            'type' : r.q(const).float, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'locals' : Hash {
                'name' : temp, 
                'type' : $*1_ltype, 
            }
, 
            'typemap' : typemap(javadirectorout) float const &, 
            'code' : $javacall, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) float const &, 
            'code' : jfloat, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) float const &, 
            'code' : float, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) float const &, 
            'code' :  $result = (jfloat)*$1; , 
            'type' : r.q(const).float, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 80, 
            }
, 
            'typemap' : typemap(typecheck) float const &, 
            'code' : , 
            'type' : r.q(const).float, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) float const &, 
            'code' : $javainput, 
            'type' : r.q(const).float, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) float const &, 
            'code' : {
    return $jnicall;
  }, 
            'type' : r.q(const).float, 
        }
, 
    }
, 
    'a(ANY).float' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) float [ANY], 
            'code' :  delete [] $1; , 
            'type' : a(ANY).float, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) float [ANY], 
            'code' : float[], 
            'type' : a(ANY).float, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) float [ANY], 
            'code' :  SWIG_JavaArrayArgoutFloat(jenv, jarr$argnum, $1, $input); , 
            'type' : a(ANY).float, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jfloat, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) float [ANY], 
            'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
    SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
    return $null;
  }
  if (!SWIG_JavaArrayInFloat(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a(ANY).float, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) float [ANY], 
            'code' : jfloatArray, 
            'type' : a(ANY).float, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) float [ANY], 
            'code' : float[], 
            'type' : a(ANY).float, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) float [ANY], 
            'code' : $result = SWIG_JavaArrayOutFloat(jenv, $1, $1_dim0); , 
            'type' : a(ANY).float, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) float [ANY], 
            'code' : $javainput, 
            'type' : a(ANY).float, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1080, 
            }
, 
            'typemap' : typemap(typecheck) float [ANY], 
            'code' : , 
            'type' : a(ANY).float, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) float [ANY], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a(ANY).float, 
        }
, 
    }
, 
    'a().float' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) float [], 
            'code' :  delete [] $1; , 
            'type' : a().float, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) float [], 
            'code' : float[], 
            'type' : a().float, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) float [], 
            'code' :  SWIG_JavaArrayArgoutFloat(jenv, jarr$argnum, $1, $input); , 
            'type' : a().float, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jfloat, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) float [], 
            'code' :   if (!SWIG_JavaArrayInFloat(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().float, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) float [], 
            'code' : jfloatArray, 
            'type' : a().float, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) float [], 
            'code' : float[], 
            'type' : a().float, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) float [], 
            'code' : $result = SWIG_JavaArrayOutFloat(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().float, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) float [], 
            'code' : $javainput, 
            'type' : a().float, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1080, 
            }
, 
            'typemap' : typemap(typecheck) float [], 
            'code' : , 
            'type' : a().float, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) float [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().float, 
        }
, 
    }
, 
    'a().int' : Hash {
        'tmap:freearg' : Hash {
            'typemap' : typemap(freearg) int [], 
            'code' :  delete [] $1; , 
            'type' : a().int, 
        }
, 
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) int [], 
            'code' : int[], 
            'type' : a().int, 
        }
, 
        'tmap:argout' : Hash {
            'typemap' : typemap(argout) int [], 
            'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, $1, $input); , 
            'type' : a().int, 
        }
, 
        'tmap:in' : Hash {
            'locals' : Hash {
                'name' : jarr, 
                'type' : p.jint, 
            }
, 
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) int [], 
            'code' :   if (!SWIG_JavaArrayInInt(jenv, &jarr, &$1, $input)) return $null; , 
            'type' : a().int, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) int [], 
            'code' : jintArray, 
            'type' : a().int, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) int [], 
            'code' : int[], 
            'type' : a().int, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) int [], 
            'code' : $result = SWIG_JavaArrayOutInt(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); , 
            'type' : a().int, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) int [], 
            'code' : $javainput, 
            'type' : a().int, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1045, 
            }
, 
            'typemap' : typemap(typecheck) int [], 
            'code' : , 
            'type' : a().int, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) int [], 
            'code' : {
    return $jnicall;
  }, 
            'type' : a().int, 
        }
, 
    }
, 
    'jcharArray' : Hash {
        'tmap:jstype' : Hash {
            'typemap' : typemap(jstype) jcharArray, 
            'code' : char[], 
            'type' : jcharArray, 
        }
, 
        'tmap:directorin' : Hash {
            'kwargs' : Hash {
                'name' : descriptor, 
                'value' : [C, 
            }
, 
            'typemap' : typemap(directorin) jcharArray, 
            'code' : $input = $1;, 
            'type' : jcharArray, 
        }
, 
        'tmap:javadirectorin' : Hash {
            'typemap' : typemap(javadirectorin) jcharArray, 
            'code' : $jniinput, 
            'type' : jcharArray, 
        }
, 
        'tmap:in' : Hash {
            'kwargs' : Hash {
                'name' : numinputs, 
                'value' : 1, 
            }
, 
            'typemap' : typemap(in) jcharArray, 
            'code' :  $1 = $input; , 
            'type' : jcharArray, 
        }
, 
        'tmap:directorout' : Hash {
            'typemap' : typemap(directorout) jcharArray, 
            'code' :  $result = $input; , 
            'type' : jcharArray, 
        }
, 
        'tmap:javadirectorout' : Hash {
            'typemap' : typemap(javadirectorout) jcharArray, 
            'code' : $javacall, 
            'type' : jcharArray, 
        }
, 
        'tmap:jni' : Hash {
            'typemap' : typemap(jni) jcharArray, 
            'code' : jcharArray, 
            'type' : jcharArray, 
        }
, 
        'tmap:jtype' : Hash {
            'typemap' : typemap(jtype) jcharArray, 
            'code' : char[], 
            'type' : jcharArray, 
        }
, 
        'tmap:out' : Hash {
            'typemap' : typemap(out) jcharArray, 
            'code' :  $result = $1; , 
            'type' : jcharArray, 
        }
, 
        'tmap:typecheck' : Hash {
            'kwargs' : Hash {
                'name' : precedence, 
                'value' : 1130, 
            }
, 
            'typemap' : typemap(typecheck) jcharArray, 
            'code' : , 
            'type' : jcharArray, 
        }
, 
        'tmap:javain' : Hash {
            'typemap' : typemap(javain) jcharArray, 
            'code' : $javainput, 
            'type' : jcharArray, 
        }
, 
        'tmap:javaout' : Hash {
            'typemap' : typemap(javaout) jcharArray, 
            'code' : {
    return $jnicall;
  }, 
            'type' : jcharArray, 
        }
, 
    }
, 
}

-----------------------------------------------------------------------------
Compiling...
Linking...
Checking yaz4jlibJNI...
  public final static native long ZOOM_record_get_bytes(long jarg1, String jarg2, long jarg3);
Checking yaz4jlib...
  public static CharStarByteArray ZOOM_record_get_bytes(SWIGTYPE_p_ZOOM_record rec, String type, SWIGTYPE_p_int len) {
    return new CharStarByteArray(yaz4jlibJNI.ZOOM_record_get_bytes(SWIGTYPE_p_ZOOM_record.getCPtr(rec), type, SWIGTYPE_p_int.getCPtr(len)), true);