#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for gpg4win 5.0.0-beta395.
#
# Report bugs to <https://bugs.gnupg.org>.
#
#
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

# Use a proper internal environment variable to ensure we don't fall
  # into an infinite loop, continuously re-executing ourselves.
  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
    _as_can_reexec=no; export _as_can_reexec;
    # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
as_fn_exit 255
  fi
  # We don't want this to propagate to other subprocesses.
          { _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
test -x / || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  export CONFIG_SHELL
             # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org and
$0: https://bugs.gnupg.org about your system, including any
$0: error possibly output before this message. Then install
$0: a modern shell, or manually run the script under such a
$0: shell if you do have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p

# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }

  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
  # already done that, so ensure we don't try to do so again and fall
  # in an infinite loop.  This has already happened in practice.
  _as_can_reexec=no; export _as_can_reexec
  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


test -n "$DJDIR" || exec 7<&0 </dev/null
exec 6>&1

# Name of the host.
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=

# Identity of this package.
PACKAGE_NAME='gpg4win'
PACKAGE_TARNAME='gpg4win'
PACKAGE_VERSION='5.0.0-beta395'
PACKAGE_STRING='gpg4win 5.0.0-beta395'
PACKAGE_BUGREPORT='https://bugs.gnupg.org'
PACKAGE_URL=''

ac_unique_file="src/nsis/config.nsi.in"
ac_subst_vars='am__EXEEXT_FALSE
am__EXEEXT_TRUE
LTLIBOBJS
LIBOBJS
APPIMAGE_DEBUG
appimage_build_list
appimage_pkg_gpgpass_deps
appimage_pkg_gpgpass_version
appimage_pkg_gpgpass
appimage_pkg_prison_deps
appimage_pkg_prison_version
appimage_pkg_prison
appimage_pkg_okular_deps
appimage_pkg_okular_version
appimage_pkg_okular
appimage_pkg_poppler_deps
appimage_pkg_poppler_version
appimage_pkg_poppler
appimage_pkg_kleopatra_deps
appimage_pkg_kleopatra_version
appimage_pkg_kleopatra
appimage_pkg_libkleo_deps
appimage_pkg_libkleo_version
appimage_pkg_libkleo
appimage_pkg_kmbox_deps
appimage_pkg_kmbox_version
appimage_pkg_kmbox
appimage_pkg_kmime_deps
appimage_pkg_kmime_version
appimage_pkg_kmime
appimage_pkg_mimetreeparser_deps
appimage_pkg_mimetreeparser_version
appimage_pkg_mimetreeparser
appimage_pkg_kcalendarcore_deps
appimage_pkg_kcalendarcore_version
appimage_pkg_kcalendarcore
appimage_pkg_libical_deps
appimage_pkg_libical_version
appimage_pkg_libical
appimage_pkg_kparts_deps
appimage_pkg_kparts_version
appimage_pkg_kparts
appimage_pkg_kio_deps
appimage_pkg_kio_version
appimage_pkg_kio
appimage_pkg_kservice_deps
appimage_pkg_kservice_version
appimage_pkg_kservice
appimage_pkg_kbookmarks_deps
appimage_pkg_kbookmarks_version
appimage_pkg_kbookmarks
appimage_pkg_kxmlgui_deps
appimage_pkg_kxmlgui_version
appimage_pkg_kxmlgui
appimage_pkg_ktextwidgets_deps
appimage_pkg_ktextwidgets_version
appimage_pkg_ktextwidgets
appimage_pkg_kiconthemes_deps
appimage_pkg_kiconthemes_version
appimage_pkg_kiconthemes
appimage_pkg_kconfigwidgets_deps
appimage_pkg_kconfigwidgets_version
appimage_pkg_kconfigwidgets
appimage_pkg_kwidgetsaddons_deps
appimage_pkg_kwidgetsaddons_version
appimage_pkg_kwidgetsaddons
appimage_pkg_kstatusnotifieritem_deps
appimage_pkg_kstatusnotifieritem_version
appimage_pkg_kstatusnotifieritem
appimage_pkg_kjobwidgets_deps
appimage_pkg_kjobwidgets_version
appimage_pkg_kjobwidgets
appimage_pkg_kcrash_deps
appimage_pkg_kcrash_version
appimage_pkg_kcrash
appimage_pkg_kcompletion_deps
appimage_pkg_kcompletion_version
appimage_pkg_kcompletion
appimage_pkg_threadweaver_deps
appimage_pkg_threadweaver_version
appimage_pkg_threadweaver
appimage_pkg_sonnet_deps
appimage_pkg_sonnet_version
appimage_pkg_sonnet
appimage_pkg_solid_deps
appimage_pkg_solid_version
appimage_pkg_solid
appimage_pkg_kwindowsystem_deps
appimage_pkg_kwindowsystem_version
appimage_pkg_kwindowsystem
appimage_pkg_kitemviews_deps
appimage_pkg_kitemviews_version
appimage_pkg_kitemviews
appimage_pkg_kitemmodels_deps
appimage_pkg_kitemmodels_version
appimage_pkg_kitemmodels
appimage_pkg_ki18n_deps
appimage_pkg_ki18n_version
appimage_pkg_ki18n
appimage_pkg_kguiaddons_deps
appimage_pkg_kguiaddons_version
appimage_pkg_kguiaddons
HAVE_PKG_KDBUSADDONS
appimage_pkg_kdbusaddons_deps
appimage_pkg_kdbusaddons_version
appimage_pkg_kdbusaddons
appimage_pkg_kcoreaddons_deps
appimage_pkg_kcoreaddons_version
appimage_pkg_kcoreaddons
appimage_pkg_kconfig_deps
appimage_pkg_kconfig_version
appimage_pkg_kconfig
appimage_pkg_kcolorscheme_deps
appimage_pkg_kcolorscheme_version
appimage_pkg_kcolorscheme
appimage_pkg_kcodecs_deps
appimage_pkg_kcodecs_version
appimage_pkg_kcodecs
HAVE_PKG_KAUTH
appimage_pkg_kauth_deps
appimage_pkg_kauth_version
appimage_pkg_kauth
appimage_pkg_karchive_deps
appimage_pkg_karchive_version
appimage_pkg_karchive
appimage_pkg_breeze_icons_deps
appimage_pkg_breeze_icons_version
appimage_pkg_breeze_icons
appimage_pkg_extra_cmake_modules_deps
appimage_pkg_extra_cmake_modules_version
appimage_pkg_extra_cmake_modules
appimage_pkg_breeze_deps
appimage_pkg_breeze_version
appimage_pkg_breeze
HAVE_PKG_PLASMA_WAYLAND_PROTOCOLS
appimage_pkg_plasma_wayland_protocols_deps
appimage_pkg_plasma_wayland_protocols_version
appimage_pkg_plasma_wayland_protocols
HAVE_PKG_WAYLAND_PROTOCOLS
appimage_pkg_wayland_protocols_deps
appimage_pkg_wayland_protocols_version
appimage_pkg_wayland_protocols
HAVE_PKG_QTWAYLAND
appimage_pkg_qtwayland_deps
appimage_pkg_qtwayland_version
appimage_pkg_qtwayland
appimage_pkg_qtsvg_deps
appimage_pkg_qtsvg_version
appimage_pkg_qtsvg
appimage_pkg_qttranslations_deps
appimage_pkg_qttranslations_version
appimage_pkg_qttranslations
appimage_pkg_qttools_deps
appimage_pkg_qttools_version
appimage_pkg_qttools
appimage_pkg_qtbase_deps
appimage_pkg_qtbase_version
appimage_pkg_qtbase
appimage_pkg_pcre2_deps
appimage_pkg_pcre2_version
appimage_pkg_pcre2
appimage_pkg_zstd_deps
appimage_pkg_zstd_version
appimage_pkg_zstd
appimage_pkg_paperkey_deps
appimage_pkg_paperkey_version
appimage_pkg_paperkey
appimage_pkg_qgpgme_deps
appimage_pkg_qgpgme_version
appimage_pkg_qgpgme
appimage_pkg_gpgmepp_deps
appimage_pkg_gpgmepp_version
appimage_pkg_gpgmepp
appimage_pkg_gpgme_deps
appimage_pkg_gpgme_version
appimage_pkg_gpgme
appimage_pkg_pinentry_deps
appimage_pkg_pinentry_version
appimage_pkg_pinentry
HAVE_PKG_GNUPG
appimage_pkg_gnupg_deps
appimage_pkg_gnupg_version
appimage_pkg_gnupg
HAVE_PKG_NTBTLS
appimage_pkg_ntbtls_deps
appimage_pkg_ntbtls_version
appimage_pkg_ntbtls
HAVE_PKG_LIBKSBA
appimage_pkg_libksba_deps
appimage_pkg_libksba_version
appimage_pkg_libksba
HAVE_PKG_LIBGCRYPT
appimage_pkg_libgcrypt_deps
appimage_pkg_libgcrypt_version
appimage_pkg_libgcrypt
HAVE_PKG_NPTH
appimage_pkg_npth_deps
appimage_pkg_npth_version
appimage_pkg_npth
appimage_pkg_libassuan_deps
appimage_pkg_libassuan_version
appimage_pkg_libassuan
appimage_pkg_libgpg_error_deps
appimage_pkg_libgpg_error_version
appimage_pkg_libgpg_error
HAVE_PKG_XCB_UTIL_CURSOR
appimage_pkg_xcb_util_cursor_deps
appimage_pkg_xcb_util_cursor_version
appimage_pkg_xcb_util_cursor
appimage_pkg_qrencode_deps
appimage_pkg_qrencode_version
appimage_pkg_qrencode
appimage_pkg_jpeg_deps
appimage_pkg_jpeg_version
appimage_pkg_jpeg
HAVE_PKG_SQLITE
appimage_pkg_sqlite_deps
appimage_pkg_sqlite_version
appimage_pkg_sqlite
appimage_pkg_freetype_deps
appimage_pkg_freetype_version
appimage_pkg_freetype
appimage_packages
GPG4WIN_DEBUG
gpg4win_build_ex_list
gpg4win_nsis_list
gpg4win_build_list
HAVE_PKG_GPGOLJS
gpg4win_pkg_gpgoljs_deps
gpg4win_pkg_gpgoljs_version
gpg4win_pkg_gpgoljs
HAVE_PKG_KCONTACTS
gpg4win_pkg_kcontacts_deps
gpg4win_pkg_kcontacts_version
gpg4win_pkg_kcontacts
HAVE_PKG_GPGPASS
gpg4win_pkg_gpgpass_deps
gpg4win_pkg_gpgpass_version
gpg4win_pkg_gpgpass
HAVE_PKG_KSTATUSNOTIFIERITEM
gpg4win_pkg_kstatusnotifieritem_deps
gpg4win_pkg_kstatusnotifieritem_version
gpg4win_pkg_kstatusnotifieritem
HAVE_PKG_PRISON
gpg4win_pkg_prison_deps
gpg4win_pkg_prison_version
gpg4win_pkg_prison
HAVE_PKG_MIMETREEPARSER
gpg4win_pkg_mimetreeparser_deps
gpg4win_pkg_mimetreeparser_version
gpg4win_pkg_mimetreeparser
HAVE_PKG_KCALENDARCORE
gpg4win_pkg_kcalendarcore_deps
gpg4win_pkg_kcalendarcore_version
gpg4win_pkg_kcalendarcore
HAVE_PKG_LIBICAL
gpg4win_pkg_libical_deps
gpg4win_pkg_libical_version
gpg4win_pkg_libical
HAVE_PKG_OKULAR
gpg4win_pkg_okular_deps
gpg4win_pkg_okular_version
gpg4win_pkg_okular
HAVE_PKG_KPARTS
gpg4win_pkg_kparts_deps
gpg4win_pkg_kparts_version
gpg4win_pkg_kparts
HAVE_PKG_POPPLER
gpg4win_pkg_poppler_deps
gpg4win_pkg_poppler_version
gpg4win_pkg_poppler
HAVE_PKG_KTEXTWIDGETS
gpg4win_pkg_ktextwidgets_deps
gpg4win_pkg_ktextwidgets_version
gpg4win_pkg_ktextwidgets
HAVE_PKG_SONNET
gpg4win_pkg_sonnet_deps
gpg4win_pkg_sonnet_version
gpg4win_pkg_sonnet
HAVE_PKG_FREETYPE
gpg4win_pkg_freetype_deps
gpg4win_pkg_freetype_version
gpg4win_pkg_freetype
HAVE_PKG_KCOLORSCHEME
gpg4win_pkg_kcolorscheme_deps
gpg4win_pkg_kcolorscheme_version
gpg4win_pkg_kcolorscheme
HAVE_PKG_THREADWEAVER
gpg4win_pkg_threadweaver_deps
gpg4win_pkg_threadweaver_version
gpg4win_pkg_threadweaver
HAVE_PKG_GPG4WIN_TOOLS
gpg4win_pkg_gpg4win_tools_deps
gpg4win_pkg_gpg4win_tools_version
gpg4win_pkg_gpg4win_tools
HAVE_PKG_LIBKLEO
gpg4win_pkg_libkleo_deps
gpg4win_pkg_libkleo_version
gpg4win_pkg_libkleo
HAVE_PKG_KXMLGUI
gpg4win_pkg_kxmlgui_deps
gpg4win_pkg_kxmlgui_version
gpg4win_pkg_kxmlgui
HAVE_PKG_KICONTHEMES
gpg4win_pkg_kiconthemes_deps
gpg4win_pkg_kiconthemes_version
gpg4win_pkg_kiconthemes
HAVE_PKG_KIO
gpg4win_pkg_kio_deps
gpg4win_pkg_kio_version
gpg4win_pkg_kio
HAVE_PKG_KBOOKMARKS
gpg4win_pkg_kbookmarks_deps
gpg4win_pkg_kbookmarks_version
gpg4win_pkg_kbookmarks
HAVE_PKG_KSERVICE
gpg4win_pkg_kservice_deps
gpg4win_pkg_kservice_version
gpg4win_pkg_kservice
HAVE_PKG_KJOBWIDGETS
gpg4win_pkg_kjobwidgets_deps
gpg4win_pkg_kjobwidgets_version
gpg4win_pkg_kjobwidgets
HAVE_PKG_SOLID
gpg4win_pkg_solid_deps
gpg4win_pkg_solid_version
gpg4win_pkg_solid
HAVE_PKG_KCRASH
gpg4win_pkg_kcrash_deps
gpg4win_pkg_kcrash_version
gpg4win_pkg_kcrash
HAVE_PKG_KARCHIVE
gpg4win_pkg_karchive_deps
gpg4win_pkg_karchive_version
gpg4win_pkg_karchive
HAVE_PKG_KITEMMODELS
gpg4win_pkg_kitemmodels_deps
gpg4win_pkg_kitemmodels_version
gpg4win_pkg_kitemmodels
HAVE_PKG_KITEMVIEWS
gpg4win_pkg_kitemviews_deps
gpg4win_pkg_kitemviews_version
gpg4win_pkg_kitemviews
HAVE_PKG_KCONFIGWIDGETS
gpg4win_pkg_kconfigwidgets_deps
gpg4win_pkg_kconfigwidgets_version
gpg4win_pkg_kconfigwidgets
HAVE_PKG_KMBOX
gpg4win_pkg_kmbox_deps
gpg4win_pkg_kmbox_version
gpg4win_pkg_kmbox
HAVE_PKG_KMIME
gpg4win_pkg_kmime_deps
gpg4win_pkg_kmime_version
gpg4win_pkg_kmime
HAVE_PKG_KGUIADDONS
gpg4win_pkg_kguiaddons_deps
gpg4win_pkg_kguiaddons_version
gpg4win_pkg_kguiaddons
HAVE_PKG_KCODECS
gpg4win_pkg_kcodecs_deps
gpg4win_pkg_kcodecs_version
gpg4win_pkg_kcodecs
HAVE_PKG_KCOREADDONS
gpg4win_pkg_kcoreaddons_deps
gpg4win_pkg_kcoreaddons_version
gpg4win_pkg_kcoreaddons
HAVE_PKG_KWINDOWSYSTEM
gpg4win_pkg_kwindowsystem_deps
gpg4win_pkg_kwindowsystem_version
gpg4win_pkg_kwindowsystem
HAVE_PKG_KCOMPLETION
gpg4win_pkg_kcompletion_deps
gpg4win_pkg_kcompletion_version
gpg4win_pkg_kcompletion
HAVE_PKG_KWIDGETSADDONS
gpg4win_pkg_kwidgetsaddons_deps
gpg4win_pkg_kwidgetsaddons_version
gpg4win_pkg_kwidgetsaddons
HAVE_PKG_KI18N
gpg4win_pkg_ki18n_deps
gpg4win_pkg_ki18n_version
gpg4win_pkg_ki18n
HAVE_PKG_KCONFIG
gpg4win_pkg_kconfig_deps
HAVE_PKG_EXTRA_CMAKE_MODULES
gpg4win_pkg_extra_cmake_modules_deps
HAVE_PKG_KLEOPATRA
gpg4win_pkg_kleopatra_deps
gpg4win_pkg_kleopatra_version
gpg4win_pkg_kleopatra
HAVE_PKG_BREEZE_ICONS
gpg4win_pkg_breeze_icons_deps
HAVE_PKG_OPENJPEG
gpg4win_pkg_openjpeg_deps
gpg4win_pkg_openjpeg_version
gpg4win_pkg_openjpeg
HAVE_PKG_BREEZE
gpg4win_pkg_breeze_deps
gpg4win_pkg_breeze_version
gpg4win_pkg_breeze
HAVE_PKG_PCRE2
gpg4win_pkg_pcre2_deps
gpg4win_pkg_pcre2_version
gpg4win_pkg_pcre2
HAVE_PKG_TIFF
gpg4win_pkg_tiff_deps
gpg4win_pkg_tiff_version
gpg4win_pkg_tiff
HAVE_PKG_QTWEBSOCKETS
gpg4win_pkg_qtwebsockets_deps
gpg4win_pkg_qtwebsockets_version
gpg4win_pkg_qtwebsockets
HAVE_PKG_QTHTTPSERVER
gpg4win_pkg_qthttpserver_deps
gpg4win_pkg_qthttpserver_version
gpg4win_pkg_qthttpserver
HAVE_PKG_QTSVG
gpg4win_pkg_qtsvg_deps
gpg4win_pkg_qtsvg_version
gpg4win_pkg_qtsvg
HAVE_PKG_QTTRANSLATIONS
gpg4win_pkg_qttranslations_deps
gpg4win_pkg_qttranslations_version
gpg4win_pkg_qttranslations
HAVE_PKG_QTTOOLS
gpg4win_pkg_qttools_deps
HAVE_PKG_QTBASE
gpg4win_pkg_qtbase_deps
HAVE_PKG_ZSTD
gpg4win_pkg_zstd_deps
gpg4win_pkg_zstd_version
gpg4win_pkg_zstd
HAVE_PKG_KCONFIG_NATIVE
gpg4win_pkg_kconfig_native_deps
gpg4win_pkg_kconfig_version
gpg4win_pkg_kconfig
HAVE_PKG_QTTOOLS_NATIVE
gpg4win_pkg_qttools_native_deps
gpg4win_pkg_qttools_version
gpg4win_pkg_qttools
HAVE_PKG_BREEZE_ICONS_NATIVE
gpg4win_pkg_breeze_icons_native_deps
gpg4win_pkg_breeze_icons_version
gpg4win_pkg_breeze_icons
HAVE_PKG_EXTRA_CMAKE_MODULES_NATIVE
gpg4win_pkg_extra_cmake_modules_native_deps
gpg4win_pkg_extra_cmake_modules_version
gpg4win_pkg_extra_cmake_modules
HAVE_PKG_QTBASE_NATIVE
gpg4win_pkg_qtbase_native_deps
gpg4win_pkg_qtbase_version
gpg4win_pkg_qtbase
HAVE_PKG_GNUPG_MSI
gpg4win_pkg_gnupg_msi_src
gpg4win_pkg_gnupg_msi_deps
gpg4win_pkg_gnupg_msi_version
gpg4win_pkg_gnupg_msi
HAVE_PKG_GNUPG_W32
gpg4win_pkg_gnupg_w32_src
gpg4win_pkg_gnupg_w32_deps
gpg4win_pkg_gnupg_w32_version
gpg4win_pkg_gnupg_w32
HAVE_PKG_GPGOL_EX
gpg4win_pkg_gpgol_ex_deps
gpg4win_pkg_gpgmepp_ex_deps
HAVE_PKG_GPGME_EX
gpg4win_pkg_gpgme_ex_deps
HAVE_PKG_GPGEX_EX
gpg4win_pkg_gpgex_ex_deps
HAVE_PKG_LIBASSUAN_EX
gpg4win_pkg_libassuan_ex_deps
HAVE_PKG_LIBGPG_ERROR_EX
gpg4win_pkg_libgpg_error_ex_deps
HAVE_PKG_QRENCODE
gpg4win_pkg_qrencode_deps
gpg4win_pkg_qrencode_version
gpg4win_pkg_qrencode
HAVE_PKG_JPEG
gpg4win_pkg_jpeg_deps
gpg4win_pkg_jpeg_version
gpg4win_pkg_jpeg
HAVE_PKG_LIBPNG
gpg4win_pkg_libpng_deps
gpg4win_pkg_libpng_version
gpg4win_pkg_libpng
HAVE_PKG_GETTEXT
gpg4win_pkg_gettext_deps
gpg4win_pkg_gettext_version
gpg4win_pkg_gettext
HAVE_PKG_LIBICONV
gpg4win_pkg_libiconv_deps
gpg4win_pkg_libiconv_version
gpg4win_pkg_libiconv
HAVE_PKG_PAPERKEY
gpg4win_pkg_paperkey_deps
gpg4win_pkg_paperkey_version
gpg4win_pkg_paperkey
HAVE_PKG_GPGEX
gpg4win_pkg_gpgex_deps
gpg4win_pkg_gpgex_version
gpg4win_pkg_gpgex
HAVE_PKG_GPGOL
gpg4win_pkg_gpgol_deps
gpg4win_pkg_gpgol_version
gpg4win_pkg_gpgol
HAVE_PKG_QGPGME
gpg4win_pkg_qgpgme_deps
gpg4win_pkg_qgpgme_version
gpg4win_pkg_qgpgme
HAVE_PKG_GPGMEPP
gpg4win_pkg_gpgmepp_deps
gpg4win_pkg_gpgmepp_version
gpg4win_pkg_gpgmepp
HAVE_PKG_GPGME
gpg4win_pkg_gpgme_deps
gpg4win_pkg_gpgme_version
gpg4win_pkg_gpgme
HAVE_PKG_PINENTRY
gpg4win_pkg_pinentry_deps
gpg4win_pkg_pinentry_version
gpg4win_pkg_pinentry
HAVE_PKG_SCUTE
gpg4win_pkg_scute_deps
gpg4win_pkg_scute_version
gpg4win_pkg_scute
HAVE_PKG_LIBASSUAN
gpg4win_pkg_libassuan_deps
gpg4win_pkg_libassuan_version
gpg4win_pkg_libassuan
HAVE_PKG_LIBGPG_ERROR
gpg4win_pkg_libgpg_error_deps
gpg4win_pkg_libgpg_error_version
gpg4win_pkg_libgpg_error
HAVE_PKG_BZIP2
gpg4win_pkg_bzip2_deps
gpg4win_pkg_bzip2_version
gpg4win_pkg_bzip2
HAVE_PKG_PKGCONFIG
gpg4win_pkg_pkgconfig_src
gpg4win_pkg_pkgconfig_deps
gpg4win_pkg_pkgconfig_version
gpg4win_pkg_pkgconfig
HAVE_PKG_ZLIB
gpg4win_pkg_zlib_deps
gpg4win_pkg_zlib_version
gpg4win_pkg_zlib
gpg4win_packages
NSIFILES
POFILES
POTFILES
LINGUAS
PLAYGROUND
TOPSRCDIR
WGET
gpg4win_rtlib_libgcc_s_sjlj_1
gpg4win_rtlib_libgcc_s_dw2_1
gpg4win_rtlib_ex_libwinpthread_1
gpg4win_rtlib_libwinpthread_1
gpg4win_rtlib_libstdc___6
BUILD_W64
gpg4win_rtlib_libgcc_s_seh_1
W32CC32
GPG4WIN_PARALLEL
ac_ct_STRIP_EX
STRIP_EX
MAKETOOL
CMAKE_GENERATOR_FLAGS
NINJA
RSYNC
CMAKE
BUILD_CC
GITLOG_TO_CHANGELOG
MSGFMT
SHA1SUM
CONVERT
DVIPDF
TEXI2DVI
ZCAT
MAKENSIS
STOW
RM
CP
MKDIR
TAR
UNZIP
MAKE
ac_ct_DLLTOOL
DLLTOOL
ac_ct_STRIP
AR
RANLIB
CPP
am__fastdepCC_FALSE
am__fastdepCC_TRUE
CCDEPMODE
am__nodep
AMDEPBACKSLASH
AMDEP_FALSE
AMDEP_TRUE
am__include
DEPDIR
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
BUILD_W64_COND_FALSE
BUILD_W64_COND_TRUE
BUILD_APPIMAGE_FALSE
BUILD_APPIMAGE_TRUE
BUILD_GPG4WIN_FALSE
BUILD_GPG4WIN_TRUE
DOCKERBUILD_FALSE
DOCKERBUILD_TRUE
EXTRA_MAKENSIS_FLAGS
GPGEX_ADD_HOST
emacs_local_vars_end
emacs_local_vars_read_only
emacs_local_vars_begin
RELEASEHOST
BUILD_FILEVERSION_TR
BUILD_FILEVERSION
BUILD_ISODATE
BUILD_TIMESTAMP
BUILD_BETANUM
BUILD_COMMITID
IS_GPD_BUILD
IS_VSD_BUILD
IS_BETA_BUILD
GIT_BETASTRING
COMPANY_NAME
PRODUCT_NAME
host_os
host_vendor
host_cpu
host
build_os
build_vendor
build_cpu
build
MAINT
MAINTAINER_MODE_FALSE
MAINTAINER_MODE_TRUE
AM_BACKSLASH
AM_DEFAULT_VERBOSITY
AM_DEFAULT_V
AM_V
am__untar
am__tar
AMTAR
am__leading_dot
SET_MAKE
AWK
mkdir_p
MKDIR_P
INSTALL_STRIP_PROGRAM
STRIP
install_sh
MAKEINFO
AUTOHEADER
AUTOMAKE
AUTOCONF
ACLOCAL
VERSION
PACKAGE
CYGPATH_W
am__isrc
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
runstatedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL
am__quote'
ac_subst_files=''
ac_user_opts='
enable_option_checking
enable_silent_rules
enable_maintainer_mode
enable_gpg4win
enable_appimage
with_additional_gpgex_host
enable_fast_makensis
enable_ninja
enable_dependency_tracking
with_libgcc_s_seh_1
with_libstdc___6
with_libwinpthread_1
with_libgcc_s_dw2_1
with_libgcc_s_sjlj_1
with_playground
with_packages
enable_packages
enable_pkg_zlib
enable_pkg_pkgconfig
enable_pkg_bzip2
enable_pkg_libgpg_error
enable_pkg_libassuan
enable_pkg_scute
enable_pkg_pinentry
enable_pkg_gpgme
enable_pkg_gpgmepp
enable_pkg_qgpgme
enable_pkg_gpgol
enable_pkg_gpgex
enable_pkg_paperkey
enable_pkg_libiconv
enable_pkg_gettext
enable_pkg_libpng
enable_pkg_jpeg
enable_pkg_qrencode
enable_pkg_gnupg_w32
enable_pkg_gnupg_msi
enable_pkg_qtbase
enable_pkg_extra_cmake_modules
enable_pkg_breeze_icons
enable_pkg_qttools
enable_pkg_kconfig
enable_pkg_zstd
enable_pkg_qttranslations
enable_pkg_qtsvg
enable_pkg_qthttpserver
enable_pkg_qtwebsockets
enable_pkg_tiff
enable_pkg_pcre2
enable_pkg_breeze
enable_pkg_openjpeg
enable_pkg_kleopatra
enable_pkg_ki18n
enable_pkg_kwidgetsaddons
enable_pkg_kcompletion
enable_pkg_kwindowsystem
enable_pkg_kcoreaddons
enable_pkg_kcodecs
enable_pkg_kguiaddons
enable_pkg_kmime
enable_pkg_kmbox
enable_pkg_kconfigwidgets
enable_pkg_kitemviews
enable_pkg_kitemmodels
enable_pkg_karchive
enable_pkg_kcrash
enable_pkg_solid
enable_pkg_kjobwidgets
enable_pkg_kservice
enable_pkg_kbookmarks
enable_pkg_kio
enable_pkg_kiconthemes
enable_pkg_kxmlgui
enable_pkg_libkleo
enable_pkg_gpg4win_tools
enable_pkg_threadweaver
enable_pkg_kcolorscheme
enable_pkg_freetype
enable_pkg_sonnet
enable_pkg_ktextwidgets
enable_pkg_poppler
enable_pkg_kparts
enable_pkg_okular
enable_pkg_libical
enable_pkg_kcalendarcore
enable_pkg_mimetreeparser
enable_pkg_prison
enable_pkg_kstatusnotifieritem
enable_pkg_gpgpass
enable_pkg_kcontacts
enable_pkg_gpgoljs
enable_debug
enable_pkg_sqlite
enable_pkg_xcb_util_cursor
enable_pkg_npth
enable_pkg_libgcrypt
enable_pkg_libksba
enable_pkg_ntbtls
enable_pkg_gnupg
enable_pkg_qtwayland
enable_pkg_wayland_protocols
enable_pkg_plasma_wayland_protocols
enable_pkg_kauth
enable_pkg_kdbusaddons
'
      ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP'


# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null
exec_prefix=NONE
no_create=
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
verbose=
x_includes=NONE
x_libraries=NONE

# Installation directory options.
# These are left unexpanded so users can "make install exec_prefix=/foo"
# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'

ac_prev=
ac_dashdash=
for ac_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval $ac_prev=\$ac_option
    ac_prev=
    continue
  fi

  case $ac_option in
  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
  *=)   ac_optarg= ;;
  *)    ac_optarg=yes ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $ac_dashdash$ac_option in
  --)
    ac_dashdash=yes ;;

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir=$ac_optarg ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build_alias ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build_alias=$ac_optarg ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file=$ac_optarg ;;

  --config-cache | -C)
    cache_file=config.cache ;;

  -datadir | --datadir | --datadi | --datad)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=*)
    datadir=$ac_optarg ;;

  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
  | --dataroo | --dataro | --datar)
    ac_prev=datarootdir ;;
  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
    datarootdir=$ac_optarg ;;

  -disable-* | --disable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=no ;;

  -docdir | --docdir | --docdi | --doc | --do)
    ac_prev=docdir ;;
  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
    docdir=$ac_optarg ;;

  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
    ac_prev=dvidir ;;
  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
    dvidir=$ac_optarg ;;

  -enable-* | --enable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=\$ac_optarg ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix=$ac_optarg ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he | -h)
    ac_init_help=long ;;
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
    ac_init_help=recursive ;;
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
    ac_init_help=short ;;

  -host | --host | --hos | --ho)
    ac_prev=host_alias ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host_alias=$ac_optarg ;;

  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
    ac_prev=htmldir ;;
  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
  | --ht=*)
    htmldir=$ac_optarg ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir=$ac_optarg ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir=$ac_optarg ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir=$ac_optarg ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir=$ac_optarg ;;

  -localedir | --localedir | --localedi | --localed | --locale)
    ac_prev=localedir ;;
  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
    localedir=$ac_optarg ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst | --locals)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
    localstatedir=$ac_optarg ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir=$ac_optarg ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c | -n)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir=$ac_optarg ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix=$ac_optarg ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix=$ac_optarg ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix=$ac_optarg ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name=$ac_optarg ;;

  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
    ac_prev=pdfdir ;;
  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
    pdfdir=$ac_optarg ;;

  -psdir | --psdir | --psdi | --psd | --ps)
    ac_prev=psdir ;;
  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
    psdir=$ac_optarg ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -runstatedir | --runstatedir | --runstatedi | --runstated \
  | --runstate | --runstat | --runsta | --runst | --runs \
  | --run | --ru | --r)
    ac_prev=runstatedir ;;
  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
  | --run=* | --ru=* | --r=*)
    runstatedir=$ac_optarg ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir=$ac_optarg ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir=$ac_optarg ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site=$ac_optarg ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir=$ac_optarg ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir=$ac_optarg ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target_alias ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target_alias=$ac_optarg ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers | -V)
    ac_init_version=: ;;

  -with-* | --with-*)
    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=\$ac_optarg ;;

  -without-* | --without-*)
    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=no ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes=$ac_optarg ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries=$ac_optarg ;;

  -*) as_fn_error $? "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information"
    ;;

  *=*)
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
    # Reject names that are not valid shell variable names.
    case $ac_envvar in #(
      '' | [0-9]* | *[!_$as_cr_alnum]* )
      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
    esac
    eval $ac_envvar=\$ac_optarg
    export $ac_envvar ;;

  *)
    # FIXME: should be removed in autoconf 3.0.
    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
    ;;

  esac
done

if test -n "$ac_prev"; then
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
  as_fn_error $? "missing argument to $ac_option"
fi

if test -n "$ac_unrecognized_opts"; then
  case $enable_option_checking in
    no) ;;
    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
  esac
fi

# Check all directory arguments for consistency.
for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
		datadir sysconfdir sharedstatedir localstatedir includedir \
		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
		libdir localedir mandir runstatedir
do
  eval ac_val=\$$ac_var
  # Remove trailing slashes.
  case $ac_val in
    */ )
      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
      eval $ac_var=\$ac_val;;
  esac
  # Be sure to have absolute directory names.
  case $ac_val in
    [\\/$]* | ?:[\\/]* )  continue;;
    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
  esac
  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
done

# There might be people who depend on the old broken behavior: `$host'
# used to hold the argument of --host etc.
# FIXME: To remove some day.
build=$build_alias
host=$host_alias
target=$target_alias

# FIXME: To remove some day.
if test "x$host_alias" != x; then
  if test "x$build_alias" = x; then
    cross_compiling=maybe
  elif test "x$build_alias" != "x$host_alias"; then
    cross_compiling=yes
  fi
fi

ac_tool_prefix=
test -n "$host_alias" && ac_tool_prefix=$host_alias-

test "$silent" = yes && exec 6>/dev/null


ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
  as_fn_error $? "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
  as_fn_error $? "pwd does not report name of working directory"


# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then the parent directory.
  ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_myself" : 'X\(//\)[^/]' \| \
	 X"$as_myself" : 'X\(//\)$' \| \
	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_myself" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  srcdir=$ac_confdir
  if test ! -r "$srcdir/$ac_unique_file"; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
	pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
  srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
  eval ac_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_env_${ac_var}_value=\$${ac_var}
  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_cv_env_${ac_var}_value=\$${ac_var}
done

#
# Report the --help message.
#
if test "$ac_init_help" = "long"; then
  # Omit some internal or obsolete options to make the list less imposing.
  # This message is too long to be a string in the A/UX 3.1 sh.
  cat <<_ACEOF
\`configure' configures gpg4win 5.0.0-beta395 to adapt to many kinds of systems.

Usage: $0 [OPTION]... [VAR=VALUE]...

To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE.  See below for descriptions of some of the useful variables.

Defaults for the options are specified in brackets.

Configuration:
  -h, --help              display this help and exit
      --help=short        display options specific to this package
      --help=recursive    display the short help of all the included packages
  -V, --version           display version information and exit
  -q, --quiet, --silent   do not print \`checking ...' messages
      --cache-file=FILE   cache test results in FILE [disabled]
  -C, --config-cache      alias for \`--cache-file=config.cache'
  -n, --no-create         do not create output files
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']

Installation directories:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [PREFIX]

By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
for instance \`--prefix=\$HOME'.

For better control, use the options below.

Fine tuning of the installation directories:
  --bindir=DIR            user executables [EPREFIX/bin]
  --sbindir=DIR           system admin executables [EPREFIX/sbin]
  --libexecdir=DIR        program executables [EPREFIX/libexec]
  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
  --libdir=DIR            object code libraries [EPREFIX/lib]
  --includedir=DIR        C header files [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  --infodir=DIR           info documentation [DATAROOTDIR/info]
  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
  --mandir=DIR            man documentation [DATAROOTDIR/man]
  --docdir=DIR            documentation root [DATAROOTDIR/doc/gpg4win]
  --htmldir=DIR           html documentation [DOCDIR]
  --dvidir=DIR            dvi documentation [DOCDIR]
  --pdfdir=DIR            pdf documentation [DOCDIR]
  --psdir=DIR             ps documentation [DOCDIR]
_ACEOF

  cat <<\_ACEOF

Program names:
  --program-prefix=PREFIX            prepend PREFIX to installed program names
  --program-suffix=SUFFIX            append SUFFIX to installed program names
  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names

System types:
  --build=BUILD     configure for building on BUILD [guessed]
  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
_ACEOF
fi

if test -n "$ac_init_help"; then
  case $ac_init_help in
     short | recursive ) echo "Configuration of gpg4win 5.0.0-beta395:";;
   esac
  cat <<\_ACEOF

Optional Features:
  --disable-option-checking  ignore unrecognized --enable/--with options
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --enable-silent-rules   less verbose build output (undo: "make V=1")
  --disable-silent-rules  verbose build output (undo: "make V=0")
  --enable-maintainer-mode
                          enable make rules and dependencies not useful (and
                          sometimes confusing) to the casual installer
  --enable-gpg4win        build the gpg4win release
  --enable-appimage       build the appimage release
  --enable-fast-makensis  Use a less efficient compressor to speed up building
  --enable-ninja          Use ninja instead of make
  --enable-dependency-tracking
                          do not reject slow dependency extractors
  --disable-dependency-tracking
                          speeds up one-time build
  --enable-packages       enable auto-detection [[yes]]
  --enable-pkg-zlib=DIR   include package zlib
  --enable-pkg-pkgconfig=DIR
                          include package pkgconfig
  --enable-pkg-bzip2=DIR  include package bzip2
  --enable-pkg-libgpg-error=DIR
                          include package libgpg-error
  --enable-pkg-libassuan=DIR
                          include package libassuan
  --enable-pkg-scute=DIR  include package scute
  --enable-pkg-pinentry=DIR
                          include package pinentry
  --enable-pkg-gpgme=DIR  include package gpgme
  --enable-pkg-gpgmepp=DIR
                          include package gpgmepp
  --enable-pkg-qgpgme=DIR include package qgpgme
  --enable-pkg-gpgol=DIR  include package gpgol
  --enable-pkg-gpgex=DIR  include package gpgex
  --enable-pkg-paperkey=DIR
                          include package paperkey
  --enable-pkg-libiconv=DIR
                          include package libiconv
  --enable-pkg-gettext=DIR
                          include package gettext
  --enable-pkg-libpng=DIR include package libpng
  --enable-pkg-jpeg=DIR   include package jpeg
  --enable-pkg-qrencode=DIR
                          include package qrencode
  --enable-pkg-gnupg-w32=DIR
                          include package gnupg-w32
  --enable-pkg-gnupg-msi=DIR
                          include package gnupg-msi
  --enable-pkg-qtbase=DIR include package qtbase
  --enable-pkg-extra-cmake-modules=DIR
                          include package extra-cmake-modules
  --enable-pkg-breeze-icons=DIR
                          include package breeze-icons
  --enable-pkg-qttools=DIR
                          include package qttools
  --enable-pkg-kconfig=DIR
                          include package kconfig
  --enable-pkg-zstd=DIR   include package zstd
  --enable-pkg-qttranslations=DIR
                          include package qttranslations
  --enable-pkg-qtsvg=DIR  include package qtsvg
  --enable-pkg-qthttpserver=DIR
                          include package qthttpserver
  --enable-pkg-qtwebsockets=DIR
                          include package qtwebsockets
  --enable-pkg-tiff=DIR   include package tiff
  --enable-pkg-pcre2=DIR  include package pcre2
  --enable-pkg-breeze=DIR include package breeze
  --enable-pkg-openjpeg=DIR
                          include package openjpeg
  --enable-pkg-kleopatra=DIR
                          include package kleopatra
  --enable-pkg-ki18n=DIR  include package ki18n
  --enable-pkg-kwidgetsaddons=DIR
                          include package kwidgetsaddons
  --enable-pkg-kcompletion=DIR
                          include package kcompletion
  --enable-pkg-kwindowsystem=DIR
                          include package kwindowsystem
  --enable-pkg-kcoreaddons=DIR
                          include package kcoreaddons
  --enable-pkg-kcodecs=DIR
                          include package kcodecs
  --enable-pkg-kguiaddons=DIR
                          include package kguiaddons
  --enable-pkg-kmime=DIR  include package kmime
  --enable-pkg-kmbox=DIR  include package kmbox
  --enable-pkg-kconfigwidgets=DIR
                          include package kconfigwidgets
  --enable-pkg-kitemviews=DIR
                          include package kitemviews
  --enable-pkg-kitemmodels=DIR
                          include package kitemmodels
  --enable-pkg-karchive=DIR
                          include package karchive
  --enable-pkg-kcrash=DIR include package kcrash
  --enable-pkg-solid=DIR  include package solid
  --enable-pkg-kjobwidgets=DIR
                          include package kjobwidgets
  --enable-pkg-kservice=DIR
                          include package kservice
  --enable-pkg-kbookmarks=DIR
                          include package kbookmarks
  --enable-pkg-kio=DIR    include package kio
  --enable-pkg-kiconthemes=DIR
                          include package kiconthemes
  --enable-pkg-kxmlgui=DIR
                          include package kxmlgui
  --enable-pkg-libkleo=DIR
                          include package libkleo
  --enable-pkg-gpg4win-tools=DIR
                          include package gpg4win-tools
  --enable-pkg-threadweaver=DIR
                          include package threadweaver
  --enable-pkg-kcolorscheme=DIR
                          include package kcolorscheme
  --enable-pkg-freetype=DIR
                          include package freetype
  --enable-pkg-sonnet=DIR include package sonnet
  --enable-pkg-ktextwidgets=DIR
                          include package ktextwidgets
  --enable-pkg-poppler=DIR
                          include package poppler
  --enable-pkg-kparts=DIR include package kparts
  --enable-pkg-okular=DIR include package okular
  --enable-pkg-libical=DIR
                          include package libical
  --enable-pkg-kcalendarcore=DIR
                          include package kcalendarcore
  --enable-pkg-mimetreeparser=DIR
                          include package mimetreeparser
  --enable-pkg-prison=DIR include package prison
  --enable-pkg-kstatusnotifieritem=DIR
                          include package kstatusnotifieritem
  --enable-pkg-gpgpass=DIR
                          include package gpgpass
  --enable-pkg-kcontacts=DIR
                          include package kcontacts
  --enable-pkg-gpgoljs=DIR
                          include package gpgoljs
  --enable-debug          enable debugging [[no]]
  --enable-pkg-sqlite=DIR include package sqlite
  --enable-pkg-xcb-util-cursor=DIR
                          include package xcb-util-cursor
  --enable-pkg-npth=DIR   include package npth
  --enable-pkg-libgcrypt=DIR
                          include package libgcrypt
  --enable-pkg-libksba=DIR
                          include package libksba
  --enable-pkg-ntbtls=DIR include package ntbtls
  --enable-pkg-gnupg=DIR  include package gnupg
  --enable-pkg-qtwayland=DIR
                          include package qtwayland
  --enable-pkg-wayland-protocols=DIR
                          include package wayland-protocols
  --enable-pkg-plasma-wayland-protocols=DIR
                          include package plasma-wayland-protocols
  --enable-pkg-kauth=DIR  include package kauth
  --enable-pkg-kdbusaddons=DIR
                          include package kdbusaddons

Optional Packages:
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --with-additional-gpgex-host=HOST
                          Additionaly build gpgex for this host
  --with-libgcc_s_seh-1-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-libstdc++-6-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-libwinpthread-1-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-ex-libwinpthread-1-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-libgcc_s_dw2-1-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-libgcc_s_sjlj-1-dll=FILE
                          include FILE as runtime dependency for the
                          installer.
  --with-playground=DIR   Use DIR as the build directory
  --with-packages=DIR     source and binary packages [[packages]]

Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
  LIBS        libraries to pass to the linker, e.g. -l<library>
  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
              you have headers in a nonstandard directory <include dir>
  CPP         C preprocessor

Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.

Report bugs to <https://bugs.gnupg.org>.
_ACEOF
ac_status=$?
fi

if test "$ac_init_help" = "recursive"; then
  # If there are subdirs, report their specific --help.
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
    test -d "$ac_dir" ||
      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
      continue
    ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

    cd "$ac_dir" || { ac_status=$?; continue; }
    # Check for guested configure.
    if test -f "$ac_srcdir/configure.gnu"; then
      echo &&
      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
    elif test -f "$ac_srcdir/configure"; then
      echo &&
      $SHELL "$ac_srcdir/configure" --help=recursive
    else
      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
    fi || ac_status=$?
    cd "$ac_pwd" || { ac_status=$?; break; }
  done
fi

test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
  cat <<\_ACEOF
gpg4win configure 5.0.0-beta395
generated by GNU Autoconf 2.69

Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
  exit
fi

## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##

# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_compile

# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } > conftest.i && {
	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_cpp
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by gpg4win $as_me 5.0.0-beta395, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  $ $0 $@

_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    $as_echo "PATH: $as_dir"
  done
IFS=$as_save_IFS

} >&5

cat >&5 <<_ACEOF


## ----------- ##
## Core tests. ##
## ----------- ##

_ACEOF


# Keep a trace of the command line.
# Strip out --no-create and --no-recursion so they do not pile up.
# Strip out --silent because we don't want to record it for future runs.
# Also quote any args containing shell meta-characters.
# Make two passes to allow for proper duplicate-argument suppression.
ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_must_keep_next=false
for ac_pass in 1 2
do
  for ac_arg
  do
    case $ac_arg in
    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
    | -silent | --silent | --silen | --sile | --sil)
      continue ;;
    *\'*)
      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    case $ac_pass in
    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
    2)
      as_fn_append ac_configure_args1 " '$ac_arg'"
      if test $ac_must_keep_next = true; then
	ac_must_keep_next=false # Got value, back to normal.
      else
	case $ac_arg in
	  *=* | --config-cache | -C | -disable-* | --disable-* \
	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
	  | -with-* | --with-* | -without-* | --without-* | --x)
	    case "$ac_configure_args0 " in
	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
	    esac
	    ;;
	  -* ) ac_must_keep_next=true ;;
	esac
      fi
      as_fn_append ac_configure_args " '$ac_arg'"
      ;;
    esac
  done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}

# When interrupted or exit'd, cleanup temporary files, and complete
# config.log.  We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
  # Save into config.log some information that might help in debugging.
  {
    echo

    $as_echo "## ---------------- ##
## Cache variables. ##
## ---------------- ##"
    echo
    # The following way of writing the cache mishandles newlines in values,
(
  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done
  (set) 2>&1 |
    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      sed -n \
	"s/'\''/'\''\\\\'\'''\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
      ;; #(
    *)
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
)
    echo

    $as_echo "## ----------------- ##
## Output variables. ##
## ----------------- ##"
    echo
    for ac_var in $ac_subst_vars
    do
      eval ac_val=\$$ac_var
      case $ac_val in
      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
      esac
      $as_echo "$ac_var='\''$ac_val'\''"
    done | sort
    echo

    if test -n "$ac_subst_files"; then
      $as_echo "## ------------------- ##
## File substitutions. ##
## ------------------- ##"
      echo
      for ac_var in $ac_subst_files
      do
	eval ac_val=\$$ac_var
	case $ac_val in
	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
	esac
	$as_echo "$ac_var='\''$ac_val'\''"
      done | sort
      echo
    fi

    if test -s confdefs.h; then
      $as_echo "## ----------- ##
## confdefs.h. ##
## ----------- ##"
      echo
      cat confdefs.h
      echo
    fi
    test "$ac_signal" != 0 &&
      $as_echo "$as_me: caught signal $ac_signal"
    $as_echo "$as_me: exit $exit_status"
  } >&5
  rm -f core *.core core.conftest.* &&
    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
    exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h

$as_echo "/* confdefs.h */" > confdefs.h

# Predefined preprocessor variables.

cat >>confdefs.h <<_ACEOF
#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF


# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
ac_site_file2=NONE
if test -n "$CONFIG_SITE"; then
  # We do not want a PATH search for config.site.
  case $CONFIG_SITE in #((
    -*)  ac_site_file1=./$CONFIG_SITE;;
    */*) ac_site_file1=$CONFIG_SITE;;
    *)   ac_site_file1=./$CONFIG_SITE;;
  esac
elif test "x$prefix" != xNONE; then
  ac_site_file1=$prefix/share/config.site
  ac_site_file2=$prefix/etc/config.site
else
  ac_site_file1=$ac_default_prefix/share/config.site
  ac_site_file2=$ac_default_prefix/etc/config.site
fi
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
  test "x$ac_site_file" = xNONE && continue
  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
    sed 's/^/| /' "$ac_site_file" >&5
    . "$ac_site_file" \
      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See \`config.log' for more details" "$LINENO" 5; }
  fi
done

if test -r "$cache_file"; then
  # Some versions of bash will fail to source /dev/null (special files
  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
    case $cache_file in
      [\\/]* | ?:[\\/]* ) . "$cache_file";;
      *)                      . "./$cache_file";;
    esac
  fi
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
  >$cache_file
fi

# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
  eval ac_new_set=\$ac_env_${ac_var}_set
  eval ac_old_val=\$ac_cv_env_${ac_var}_value
  eval ac_new_val=\$ac_env_${ac_var}_value
  case $ac_old_set,$ac_new_set in
    set,)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,set)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,);;
    *)
      if test "x$ac_old_val" != "x$ac_new_val"; then
	# differences in whitespace do not lead to failure.
	ac_old_val_w=`echo x $ac_old_val`
	ac_new_val_w=`echo x $ac_new_val`
	if test "$ac_old_val_w" != "$ac_new_val_w"; then
	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
	  ac_cache_corrupted=:
	else
	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
	  eval $ac_var=\$ac_old_val
	fi
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
      fi;;
  esac
  # Pass precious variables to config.status.
  if test "$ac_new_set" = set; then
    case $ac_new_val in
    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
    *) ac_arg=$ac_var=$ac_new_val ;;
    esac
    case " $ac_configure_args " in
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
    esac
  fi
done
if $ac_cache_corrupted; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu




PACKAGE=$PACKAGE_NAME
VERSION=$PACKAGE_VERSION
BUILD_COMMITID="a6e380f8f455f6f5a5490a35a6afb19446aef76c"
GIT_REVISION=a6e380f8
GIT_REVISION_DEC=42723
GIT_BETASTRING=-beta395
IS_BETA_BUILD=yes
IS_VSD_BUILD=no
IS_GPD_BUILD=no

# Variables for the version info
PRODUCT_NAME="Gpg4win"
COMPANY_NAME="g10 Code GmbH"

# Early sanity checks and dirs



ac_aux_dir=
for ac_dir in build-aux "$srcdir"/build-aux; do
  if test -f "$ac_dir/install-sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install-sh -c"
    break
  elif test -f "$ac_dir/install.sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install.sh -c"
    break
  elif test -f "$ac_dir/shtool"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/shtool install -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  as_fn_error $? "cannot find install-sh, install.sh, or shtool in build-aux \"$srcdir\"/build-aux" "$LINENO" 5
fi

# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.


am__api_version='1.16'

# Find a good install program.  We prefer a C program (faster),
# so one script is as good as another.  But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if ${ac_cv_path_install+:} false; then :
  $as_echo_n "(cached) " >&6
else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    # Account for people who put trailing slashes in PATH elements.
case $as_dir/ in #((
  ./ | .// | /[cC]/* | \
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
  /usr/ucb/* ) ;;
  *)
    # OSF1 and SCO ODT 3.0 have their own names for install.
    # Don't use installbsd from OSF since it installs stuff as root
    # by default.
    for ac_prog in ginstall scoinst install; do
      for ac_exec_ext in '' $ac_executable_extensions; do
	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
	  if test $ac_prog = install &&
	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # AIX install.  It has an incompatible calling convention.
	    :
	  elif test $ac_prog = install &&
	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # program-specific install script used by HP pwplus--don't use.
	    :
	  else
	    rm -rf conftest.one conftest.two conftest.dir
	    echo one > conftest.one
	    echo two > conftest.two
	    mkdir conftest.dir
	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
	      test -s conftest.one && test -s conftest.two &&
	      test -s conftest.dir/conftest.one &&
	      test -s conftest.dir/conftest.two
	    then
	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
	      break 3
	    fi
	  fi
	fi
      done
    done
    ;;
esac

  done
IFS=$as_save_IFS

rm -rf conftest.one conftest.two conftest.dir

fi
  if test "${ac_cv_path_install+set}" = set; then
    INSTALL=$ac_cv_path_install
  else
    # As a last resort, use the slow shell script.  Don't cache a
    # value for INSTALL within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the value is a relative name.
    INSTALL=$ac_install_sh
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }

# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
# Reject unsafe characters in $srcdir or the absolute working directory
# name.  Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
  *[\\\"\#\$\&\'\`$am_lf]*)
    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac

# Do 'set' in a subshell so we don't clobber the current shell's
# arguments.  Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
   am_has_slept=no
   for am_try in 1 2; do
     echo "timestamp, slept: $am_has_slept" > conftest.file
     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
     if test "$*" = "X"; then
	# -L didn't work.
	set X `ls -t "$srcdir/configure" conftest.file`
     fi
     if test "$*" != "X $srcdir/configure conftest.file" \
	&& test "$*" != "X conftest.file $srcdir/configure"; then

	# If neither matched, then we have a broken ls.  This can happen
	# if, for instance, CONFIG_SHELL is bash and it inherits a
	# broken ls alias from the environment.  This has actually
	# happened.  Such a system could not be considered "sane".
	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
  alias in your environment" "$LINENO" 5
     fi
     if test "$2" = conftest.file || test $am_try -eq 2; then
       break
     fi
     # Just in case.
     sleep 1
     am_has_slept=yes
   done
   test "$2" = conftest.file
   )
then
   # Ok.
   :
else
   as_fn_error $? "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
  ( sleep 1 ) &
  am_sleep_pid=$!
fi

rm -f conftest.file

test "$program_prefix" != NONE &&
  program_transform_name="s&^&$program_prefix&;$program_transform_name"
# Use a double $ so make ignores it.
test "$program_suffix" != NONE &&
  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
# Double any \ or $.
# By default was `s,x,x', remove it if useless.
ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`

# Expand $ac_aux_dir to an absolute path.
am_aux_dir=`cd "$ac_aux_dir" && pwd`

if test x"${MISSING+set}" != xset; then
  MISSING="\${SHELL} '$am_aux_dir/missing'"
fi
# Use eval to expand $SHELL
if eval "$MISSING --is-lightweight"; then
  am_missing_run="$MISSING "
else
  am_missing_run=
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
fi

if test x"${install_sh+set}" != xset; then
  case $am_aux_dir in
  *\ * | *\	*)
    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
  *)
    install_sh="\${SHELL} $am_aux_dir/install-sh"
  esac
fi

# Installed binaries are usually stripped using 'strip' when the user
# run "make install-strip".  However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the 'STRIP' environment variable to overrule this program.
if test "$cross_compiling" != no; then
  if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STRIP"; then
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_STRIP"; then
  ac_ct_STRIP=$STRIP
  # Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_STRIP"; then
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_STRIP="strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_STRIP" = x; then
    STRIP=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    STRIP=$ac_ct_STRIP
  fi
else
  STRIP="$ac_cv_prog_STRIP"
fi

fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
  if ${ac_cv_path_mkdir+:} false; then :
  $as_echo_n "(cached) " >&6
else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in mkdir gmkdir; do
	 for ac_exec_ext in '' $ac_executable_extensions; do
	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
	     'mkdir (GNU coreutils) '* | \
	     'mkdir (coreutils) '* | \
	     'mkdir (fileutils) '4.1*)
	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
	       break 3;;
	   esac
	 done
       done
  done
IFS=$as_save_IFS

fi

  test -d ./--version && rmdir ./--version
  if test "${ac_cv_path_mkdir+set}" = set; then
    MKDIR_P="$ac_cv_path_mkdir -p"
  else
    # As a last resort, use the slow shell script.  Don't cache a
    # value for MKDIR_P within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the value is a relative name.
    MKDIR_P="$ac_install_sh -d"
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
$as_echo "$MKDIR_P" >&6; }

for ac_prog in gawk mawk nawk awk
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AWK+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AWK"; then
  ac_cv_prog_AWK="$AWK" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AWK="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$AWK" && break
done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
	@echo '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
  *@@@%%%=?*=@@@%%%*)
    eval ac_cv_prog_make_${ac_make}_set=yes;;
  *)
    eval ac_cv_prog_make_${ac_make}_set=no;;
esac
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  SET_MAKE=
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  SET_MAKE="MAKE=${MAKE-make}"
fi

rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
  am__leading_dot=.
else
  am__leading_dot=_
fi
rmdir .tst 2>/dev/null

# Check whether --enable-silent-rules was given.
if test "${enable_silent_rules+set}" = set; then :
  enableval=$enable_silent_rules;
fi

case $enable_silent_rules in # (((
  yes) AM_DEFAULT_VERBOSITY=0;;
   no) AM_DEFAULT_VERBOSITY=1;;
    *) AM_DEFAULT_VERBOSITY=1;;
esac
am_make=${MAKE-make}
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
if ${am_cv_make_support_nested_variables+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if $as_echo 'TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
	@$(TRUE)
.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
  am_cv_make_support_nested_variables=yes
else
  am_cv_make_support_nested_variables=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
$as_echo "$am_cv_make_support_nested_variables" >&6; }
if test $am_cv_make_support_nested_variables = yes; then
    AM_V='$(V)'
  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
  AM_V=$AM_DEFAULT_VERBOSITY
  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AM_BACKSLASH='\'

if test "`cd $srcdir && pwd`" != "`pwd`"; then
  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
  # is not polluted with repeated "-I."
  am__isrc=' -I$(srcdir)'
  # test to see if srcdir already configured
  if test -f $srcdir/config.status; then
    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
  fi
fi

# test whether we have cygpath
if test -z "$CYGPATH_W"; then
  if (cygpath --version) >/dev/null 2>/dev/null; then
    CYGPATH_W='cygpath -w'
  else
    CYGPATH_W=echo
  fi
fi


# Define the identity of the package.
 PACKAGE='gpg4win'
 VERSION='5.0.0-beta395'


cat >>confdefs.h <<_ACEOF
#define PACKAGE "$PACKAGE"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define VERSION "$VERSION"
_ACEOF

# Some tools Automake needs.

ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}


AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}


AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}


AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}


MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}

# For better backward compatibility.  To be removed once Automake 1.9.x
# dies out for good.  For more background, see:
# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
mkdir_p='$(MKDIR_P)'

# We need awk for the "check" target (and possibly the TAP driver).  The
# system "awk" is bad on some platforms.
# Always define AMTAR for backward compatibility.  Yes, it's still used
# in the wild :-(  We should find a proper way to deprecate it ...
AMTAR='$${TAR-tar}'


# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar plaintar pax cpio none'

# The POSIX 1988 'ustar' format is defined with fixed-size fields.
      # There is notably a 21 bits limit for the UID and the GID.  In fact,
      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
      # and bug#13588).
      am_max_uid=2097151 # 2^21 - 1
      am_max_gid=$am_max_uid
      # The $UID and $GID variables are not portable, so we need to resort
      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
      # below are definitely unexpected, so allow the users to see them
      # (that is, avoid stderr redirection).
      am_uid=`id -u || echo unknown`
      am_gid=`id -g || echo unknown`
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether UID '$am_uid' is supported by ustar format" >&5
$as_echo_n "checking whether UID '$am_uid' is supported by ustar format... " >&6; }
      if test $am_uid -le $am_max_uid; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      else
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
         _am_tools=none
      fi
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether GID '$am_gid' is supported by ustar format" >&5
$as_echo_n "checking whether GID '$am_gid' is supported by ustar format... " >&6; }
      if test $am_gid -le $am_max_gid; then
         { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
        _am_tools=none
      fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to create a ustar tar archive" >&5
$as_echo_n "checking how to create a ustar tar archive... " >&6; }

  # Go ahead even if we have the value already cached.  We do so because we
  # need to set the values for the 'am__tar' and 'am__untar' variables.
  _am_tools=${am_cv_prog_tar_ustar-$_am_tools}

  for _am_tool in $_am_tools; do
    case $_am_tool in
    gnutar)
      for _am_tar in tar gnutar gtar; do
        { echo "$as_me:$LINENO: $_am_tar --version" >&5
   ($_am_tar --version) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && break
      done
      am__tar="$_am_tar --format=ustar -chf - "'"$$tardir"'
      am__tar_="$_am_tar --format=ustar -chf - "'"$tardir"'
      am__untar="$_am_tar -xf -"
      ;;
    plaintar)
      # Must skip GNU tar: if it does not support --format= it doesn't create
      # ustar tarball either.
      (tar --version) >/dev/null 2>&1 && continue
      am__tar='tar chf - "$$tardir"'
      am__tar_='tar chf - "$tardir"'
      am__untar='tar xf -'
      ;;
    pax)
      am__tar='pax -L -x ustar -w "$$tardir"'
      am__tar_='pax -L -x ustar -w "$tardir"'
      am__untar='pax -r'
      ;;
    cpio)
      am__tar='find "$$tardir" -print | cpio -o -H ustar -L'
      am__tar_='find "$tardir" -print | cpio -o -H ustar -L'
      am__untar='cpio -i -H ustar -d'
      ;;
    none)
      am__tar=false
      am__tar_=false
      am__untar=false
      ;;
    esac

    # If the value was cached, stop now.  We just wanted to have am__tar
    # and am__untar set.
    test -n "${am_cv_prog_tar_ustar}" && break

    # tar/untar a dummy directory, and stop if the command works.
    rm -rf conftest.dir
    mkdir conftest.dir
    echo GrepMe > conftest.dir/file
    { echo "$as_me:$LINENO: tardir=conftest.dir && eval $am__tar_ >conftest.tar" >&5
   (tardir=conftest.dir && eval $am__tar_ >conftest.tar) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
    rm -rf conftest.dir
    if test -s conftest.tar; then
      { echo "$as_me:$LINENO: $am__untar <conftest.tar" >&5
   ($am__untar <conftest.tar) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
      { echo "$as_me:$LINENO: cat conftest.dir/file" >&5
   (cat conftest.dir/file) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
    fi
  done
  rm -rf conftest.dir

  if ${am_cv_prog_tar_ustar+:} false; then :
  $as_echo_n "(cached) " >&6
else
  am_cv_prog_tar_ustar=$_am_tool
fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_tar_ustar" >&5
$as_echo "$am_cv_prog_tar_ustar" >&6; }






# POSIX will say in a future version that running "rm -f" with no argument
# is OK; and we want to be able to make that assumption in our Makefile
# recipes.  So use an aggressive probe to check that the usage we want is
# actually supported "in the wild" to an acceptable degree.
# See automake bug#10828.
# To make any issue more visible, cause the running configure to be aborted
# by default if the 'rm' program in use doesn't match our expectations; the
# user can still override this though.
if rm -f && rm -fr && rm -rf; then : OK; else
  cat >&2 <<'END'
Oops!

Your 'rm' program seems unable to run without file operands specified
on the command line, even when the '-f' option is present.  This is contrary
to the behaviour of most rm programs out there, and not conforming with
the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>

Please tell bug-automake@gnu.org about your system, including the value
of your $PATH and any error possibly output before this message.  This
can help us improve future automake versions.

END
  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
    echo 'Configuration will proceed anyway, since you have set the' >&2
    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
    echo >&2
  else
    cat >&2 <<'END'
Aborting the configuration process, to ensure you take notice of the issue.

You can download and install GNU coreutils to get an 'rm' implementation
that behaves properly: <https://www.gnu.org/software/coreutils/>.

If you want to complete the configuration process using your problematic
'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
to "yes", and re-run configure.

END
    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
  fi
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
    # Check whether --enable-maintainer-mode was given.
if test "${enable_maintainer_mode+set}" = set; then :
  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
else
  USE_MAINTAINER_MODE=no
fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
$as_echo "$USE_MAINTAINER_MODE" >&6; }
   if test $USE_MAINTAINER_MODE = yes; then
  MAINTAINER_MODE_TRUE=
  MAINTAINER_MODE_FALSE='#'
else
  MAINTAINER_MODE_TRUE='#'
  MAINTAINER_MODE_FALSE=
fi

  MAINT=$MAINTAINER_MODE_TRUE


# Make sure we can run config.sub.
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
$as_echo_n "checking build system type... " >&6; }
if ${ac_cv_build+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_build_alias=$build_alias
test "x$ac_build_alias" = x &&
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
test "x$ac_build_alias" = x &&
  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
$as_echo "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
esac
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_build
shift
build_cpu=$1
build_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
$as_echo_n "checking host system type... " >&6; }
if ${ac_cv_host+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "x$host_alias" = x; then
  ac_cv_host=$ac_cv_build
else
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
$as_echo "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_host
shift
host_cpu=$1
host_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac


ac_config_headers="$ac_config_headers config.h"













# Generate extended version information.  Note, that for NSIS use we
# must not translate the dots to commas in the BUILD_FILEVERSION.
BUILD_TIMESTAMP=`date --iso-8601=minutes`
BUILD_ISODATE=`date --iso-8601`
BUILD_DATETIME=`date +%Y%m%d%H%M`
BUILD_FILEVERSION=`echo "$VERSION" | sed 's/\([0-9.]*\).*/\1./'`
BUILD_FILEVERSION="${BUILD_FILEVERSION}${GIT_REVISION_DEC}"
BUILD_FILEVERSION_TR=`echo "${BUILD_FILEVERSION}" | tr . ,`
BUILD_BETANUM=`let a=$(($(echo "${GIT_BETASTRING}"|sed 's/[^0-9]*//')+0));echo $a`







# The final release is copied to an archive server.  The default
# location may be changed by setting the RELEASEHOST envvar.
if test -z "$RELEASEHOST" ; then
   RELEASEHOST="vigenere:tarballs/gpg4win"
   if test "${IS_BETA_BUILD}" = yes ; then
      RELEASEHOST="${RELEASEHOST}/Beta"
   fi
fi


# Substitutions to set generated files in a Emacs buffer to read-only.
emacs_local_vars_begin='Local Variables:'

emacs_local_vars_read_only='buffer-read-only: t'

emacs_local_vars_end='End:'



   build_gpg4win=no

      # Check whether --enable-gpg4win was given.
if test "${enable_gpg4win+set}" = set; then :
  enableval=$enable_gpg4win; build_gpg4win=$enableval
else
  build_gpg4win=no
fi


   case "$build_gpg4win" in
         no|yes)
           ;;
         *)
           as_fn_error $? "only yes or no allowed for feature --enable-gpg4win" "$LINENO" 5
           ;;
   esac



   build_appimage=no

      # Check whether --enable-appimage was given.
if test "${enable_appimage+set}" = set; then :
  enableval=$enable_appimage; build_appimage=$enableval
else
  build_appimage=no
fi


   case "$build_appimage" in
         no|yes)
           ;;
         *)
           as_fn_error $? "only yes or no allowed for feature --enable-appimage" "$LINENO" 5
           ;;
   esac



# Additionaly enable building gpgex for another host

# Check whether --with-additional-gpgex-host was given.
if test "${with_additional_gpgex_host+set}" = set; then :
  withval=$with_additional_gpgex_host; if test "$withval" = yes; then
                      { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "--with-additional-gpgex-host was given,
                           but no host specified
See \`config.log' for more details" "$LINENO" 5; }
                    else
                      gpgex_host=$withval
                    fi

else
  gpgex_host=no
fi


if test "$gpgex_host" != no; then
    GPGEX_ADD_HOST="$gpgex_host"
fi


# Check whether --enable-fast-makensis was given.
if test "${enable_fast_makensis+set}" = set; then :
  enableval=$enable_fast_makensis; use_fast_makensis=$enableval
else
  use_fast_makensis=no
fi

if test "$use_fast_makensis" = yes; then
  EXTRA_MAKENSIS_FLAGS="${EXTRA_MAKENSIS_FLAGS} -DDISABLE_LZMA=1"
fi


# Use ninja instead of make for cmake projects
# Check whether --enable-ninja was given.
if test "${enable_ninja+set}" = set; then :
  enableval=$enable_ninja; use_ninja=$enableval
else
  use_ninja=no
fi


#
# Set variables for use by automake makefiles.
#
if test -f /src/packages/BUILDTYPE ; then
   dockerbuild=yes
else
   dockerbuild=no
fi
 if test "$dockerbuild" = "yes"; then
  DOCKERBUILD_TRUE=
  DOCKERBUILD_FALSE='#'
else
  DOCKERBUILD_TRUE='#'
  DOCKERBUILD_FALSE=
fi

 if test "$build_gpg4win" = "yes"; then
  BUILD_GPG4WIN_TRUE=
  BUILD_GPG4WIN_FALSE='#'
else
  BUILD_GPG4WIN_TRUE='#'
  BUILD_GPG4WIN_FALSE=
fi

 if test "$build_appimage" = "yes"; then
  BUILD_APPIMAGE_TRUE=
  BUILD_APPIMAGE_FALSE='#'
else
  BUILD_APPIMAGE_TRUE='#'
  BUILD_APPIMAGE_FALSE=
fi

 if test "$BUILD_W64" = "yes"; then
  BUILD_W64_COND_TRUE=
  BUILD_W64_COND_FALSE='#'
else
  BUILD_W64_COND_TRUE='#'
  BUILD_W64_COND_FALSE=
fi



# Required tools.
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_CC"; then
  ac_ct_CC=$CC
  # Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
else
  CC="$ac_cv_prog_CC"
fi

if test -z "$CC"; then
          if test -n "$ac_tool_prefix"; then
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi
fi
if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
       ac_prog_rejected=yes
       continue
     fi
    ac_cv_prog_CC="cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# != 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
  fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$CC"; then
  if test -n "$ac_tool_prefix"; then
  for ac_prog in cl.exe
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CC" && break
  done
fi
if test -z "$CC"; then
  ac_ct_CC=$CC
  for ac_prog in cl.exe
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CC" && break
done

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
fi

fi


test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }

# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"

ac_rmfiles=
for ac_file in $ac_files
do
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
  esac
done
rm -f $ac_rmfiles

if { { ac_try="$ac_link_default"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link_default") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
	;;
    [ab].out )
	# We found the default executable, but exeext='' is most
	# certainly right.
	break;;
    *.* )
	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
	then :; else
	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	fi
	# We set ac_cv_exeext here because the later test for it is not
	# safe: cross compilers may not add the suffix if given an `-o'
	# argument, so we may need to know it at that point already.
	# Even if this section looks crufty: it has the advantage of
	# actually working.
	break;;
    * )
	break;;
  esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=

else
  ac_file=''
fi
if test -z "$ac_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See \`config.log' for more details" "$LINENO" 5; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext

rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
# `rm'.
for ac_file in conftest.exe conftest conftest.*; do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	  break;;
    * ) break;;
  esac
done
else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }

rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdio.h>
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
 return ferror (f) || fclose (f) != 0;

  ;
  return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run.  If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
  { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if { ac_try='./conftest$ac_cv_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then
    cross_compiling=no
  else
    if test "$cross_compiling" = maybe; then
	cross_compiling=yes
    else
	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details" "$LINENO" 5; }
    fi
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }

rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if ${ac_cv_objext+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  for ac_file in conftest.o conftest.obj conftest.*; do
  test -f "$ac_file" || continue;
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
       break;;
  esac
done
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if ${ac_cv_c_compiler_gnu+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{
#ifndef __GNUC__
       choke me
#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GCC=yes
else
  GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if ${ac_cv_prog_cc_g+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_c_werror_flag=$ac_c_werror_flag
   ac_c_werror_flag=yes
   ac_cv_prog_cc_g=no
   CFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
else
  CFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  ac_c_werror_flag=$ac_save_c_werror_flag
	 CFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
  CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
  if test "$GCC" = yes; then
    CFLAGS="-g -O2"
  else
    CFLAGS="-g"
  fi
else
  if test "$GCC" = yes; then
    CFLAGS="-O2"
  else
    CFLAGS=
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if ${ac_cv_prog_cc_c89+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <stdarg.h>
#include <stdio.h>
struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
     char **p;
     int i;
{
  return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
  char *s;
  va_list v;
  va_start (v,p);
  s = g (p, va_arg (v,int));
  va_end (v);
  return s;
}

/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
   function prototypes and stuff, but not '\xHH' hex character constants.
   These don't provoke an error unfortunately, instead are silently treated
   as 'x'.  The following induces an error, until -std is added to get
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
   array size at least.  It's necessary to write '\x00'==0 to get something
   that's true only with -std.  */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];

/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
   inside strings and character constants.  */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];

int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
int argc;
char **argv;
int
main ()
{
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
  ;
  return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
  CC="$ac_save_CC $ac_arg"
  if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
  test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC

fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
  x)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
  xno)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
  *)
    CC="$CC $ac_cv_prog_cc_c89"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :

fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
if ${am_cv_prog_cc_c_o+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
  # Make sure it works both with $CC and with simple cc.
  # Following AC_PROG_CC_C_O, we do the test twice because some
  # compilers refuse to overwrite an existing .o file with -o,
  # though they will create one.
  am_cv_prog_cc_c_o=yes
  for am_i in 1 2; do
    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } \
         && test -f conftest2.$ac_objext; then
      : OK
    else
      am_cv_prog_cc_c_o=no
      break
    fi
  done
  rm -f core conftest*
  unset am_i
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
$as_echo "$am_cv_prog_cc_c_o" >&6; }
if test "$am_cv_prog_cc_c_o" != yes; then
   # Losing compiler, so override with the script.
   # FIXME: It is wrong to rewrite CC.
   # But if we don't then we get into trouble of one sort or another.
   # A longer-term fix would be to have automake use am__CC in this case,
   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
   CC="$am_aux_dir/compile $CC"
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

DEPDIR="${am__leading_dot}deps"

ac_config_commands="$ac_config_commands depfiles"

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
cat > confinc.mk << 'END'
am__doit:
	@echo this is the am__doit target >confinc.out
.PHONY: am__doit
END
am__include="#"
am__quote=
# BSD make does it like this.
echo '.include "confinc.mk" # ignored' > confmf.BSD
# Other make implementations (GNU, Solaris 10, AIX) do it like this.
echo 'include confinc.mk # ignored' > confmf.GNU
_am_result=no
for s in GNU BSD; do
  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
  case $?:`cat confinc.out 2>/dev/null` in #(
  '0:this is the am__doit target') :
    case $s in #(
  BSD) :
    am__include='.include' am__quote='"' ;; #(
  *) :
    am__include='include' am__quote='' ;;
esac ;; #(
  *) :
     ;;
esac
  if test "$am__include" != "#"; then
    _am_result="yes ($s style)"
    break
  fi
done
rm -f confinc.* confmf.*
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
$as_echo "${_am_result}" >&6; }

# Check whether --enable-dependency-tracking was given.
if test "${enable_dependency_tracking+set}" = set; then :
  enableval=$enable_dependency_tracking;
fi

if test "x$enable_dependency_tracking" != xno; then
  am_depcomp="$ac_aux_dir/depcomp"
  AMDEPBACKSLASH='\'
  am__nodep='_no'
fi
 if test "x$enable_dependency_tracking" != xno; then
  AMDEP_TRUE=
  AMDEP_FALSE='#'
else
  AMDEP_TRUE='#'
  AMDEP_FALSE=
fi



depcc="$CC"   am_compiler_list=

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if ${am_cv_CC_dependencies_compiler_type+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
  # We make a subdir and do the tests there.  Otherwise we can end up
  # making bogus files that we don't know about and never remove.  For
  # instance it was reported that on HP-UX the gcc test will end up
  # making a dummy file named 'D' -- because '-MD' means "put the output
  # in D".
  rm -rf conftest.dir
  mkdir conftest.dir
  # Copy depcomp to subdir because otherwise we won't find it if we're
  # using a relative directory.
  cp "$am_depcomp" conftest.dir
  cd conftest.dir
  # We will build objects and dependencies in a subdirectory because
  # it helps to detect inapplicable dependency modes.  For instance
  # both Tru64's cc and ICC support -MD to output dependencies as a
  # side effect of compilation, but ICC will put the dependencies in
  # the current directory while Tru64 will put them in the object
  # directory.
  mkdir sub

  am_cv_CC_dependencies_compiler_type=none
  if test "$am_compiler_list" = ""; then
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
  fi
  am__universal=false
  case " $depcc " in #(
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     esac

  for depmode in $am_compiler_list; do
    # Setup a source with many dependencies, because some compilers
    # like to wrap large dependency lists on column 80 (with \), and
    # we should not choose a depcomp mode which is confused by this.
    #
    # We need to recreate these files for each test, as the compiler may
    # overwrite some of them when testing with obscure command lines.
    # This happens at least with the AIX C compiler.
    : > sub/conftest.c
    for i in 1 2 3 4 5 6; do
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
      # Solaris 10 /bin/sh.
      echo '/* dummy */' > sub/conftst$i.h
    done
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    # mode.  It turns out that the SunPro C++ compiler does not properly
    # handle '-M -o', and we need to detect this.  Also, some Intel
    # versions had trouble with output in subdirs.
    am__obj=sub/conftest.${OBJEXT-o}
    am__minus_obj="-o $am__obj"
    case $depmode in
    gcc)
      # This depmode causes a compiler race in universal mode.
      test "$am__universal" = false || continue
      ;;
    nosideeffect)
      # After this tag, mechanisms are not by side-effect, so they'll
      # only be used when explicitly requested.
      if test "x$enable_dependency_tracking" = xyes; then
	continue
      else
	break
      fi
      ;;
    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
      # This compiler won't grok '-c -o', but also, the minuso test has
      # not run yet.  These depmodes are late enough in the game, and
      # so weak that their functioning should not be impacted.
      am__obj=conftest.${OBJEXT-o}
      am__minus_obj=
      ;;
    none) break ;;
    esac
    if depmode=$depmode \
       source=sub/conftest.c object=$am__obj \
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
         >/dev/null 2>conftest.err &&
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
      # icc doesn't choke on unknown options, it will just issue warnings
      # or remarks (even with -Werror).  So we grep stderr for any message
      # that says an option was ignored or not supported.
      # When given -MP, icc 7.0 and 7.1 complain thusly:
      #   icc: Command line warning: ignoring option '-M'; no argument required
      # The diagnosis changed in icc 8.0:
      #   icc: Command line remark: option '-MP' not supported
      if (grep 'ignoring option' conftest.err ||
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
        am_cv_CC_dependencies_compiler_type=$depmode
        break
      fi
    fi
  done

  cd ..
  rm -rf conftest.dir
else
  am_cv_CC_dependencies_compiler_type=none
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

 if
  test "x$enable_dependency_tracking" != xno \
  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
  am__fastdepCC_TRUE=
  am__fastdepCC_FALSE='#'
else
  am__fastdepCC_TRUE='#'
  am__fastdepCC_FALSE=
fi


ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
  if ${ac_cv_prog_CPP+:} false; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CPP needs to be expanded
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
    do
      ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi

    done
    ac_cv_prog_CPP=$CPP

fi
  CPP=$ac_cv_prog_CPP
else
  ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
  # <limits.h> exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <ac_nonexistent.h>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_RANLIB+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
$as_echo "$RANLIB" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_RANLIB"; then
  ac_ct_RANLIB=$RANLIB
  # Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_RANLIB"; then
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_RANLIB="ranlib"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
$as_echo "$ac_ct_RANLIB" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_RANLIB" = x; then
    RANLIB=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    RANLIB=$ac_ct_RANLIB
  fi
else
  RANLIB="$ac_cv_prog_RANLIB"
fi

for ac_prog in gawk mawk nawk awk
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AWK+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AWK"; then
  ac_cv_prog_AWK="$AWK" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AWK="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$AWK" && break
done

if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
set dummy ${ac_tool_prefix}ar; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AR"; then
  ac_cv_prog_AR="$AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AR="${ac_tool_prefix}ar"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
$as_echo "$AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_AR"; then
  ac_ct_AR=$AR
  # Extract the first word of "ar", so it can be a program name with args.
set dummy ar; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_AR"; then
  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_AR="ar"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
$as_echo "$ac_ct_AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_AR" = x; then
    AR=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    AR=$ac_ct_AR
  fi
else
  AR="$ac_cv_prog_AR"
fi

if test -n "$ac_tool_prefix"; then
  for ac_prog in strip
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STRIP"; then
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$STRIP" && break
  done
fi
if test -z "$STRIP"; then
  ac_ct_STRIP=$STRIP
  for ac_prog in strip
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_STRIP"; then
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_STRIP="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_STRIP" && break
done

  if test "x$ac_ct_STRIP" = x; then
    STRIP=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    STRIP=$ac_ct_STRIP
  fi
fi

if test -n "$ac_tool_prefix"; then
  for ac_prog in dlltool
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_DLLTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$DLLTOOL"; then
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_DLLTOOL="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
DLLTOOL=$ac_cv_prog_DLLTOOL
if test -n "$DLLTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
$as_echo "$DLLTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$DLLTOOL" && break
  done
fi
if test -z "$DLLTOOL"; then
  ac_ct_DLLTOOL=$DLLTOOL
  for ac_prog in dlltool
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_DLLTOOL"; then
  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_DLLTOOL="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
if test -n "$ac_ct_DLLTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
$as_echo "$ac_ct_DLLTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_DLLTOOL" && break
done

  if test "x$ac_ct_DLLTOOL" = x; then
    DLLTOOL=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    DLLTOOL=$ac_ct_DLLTOOL
  fi
fi

for ac_prog in make
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MAKE+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MAKE"; then
  ac_cv_prog_MAKE="$MAKE" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MAKE="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MAKE=$ac_cv_prog_MAKE
if test -n "$MAKE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKE" >&5
$as_echo "$MAKE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$MAKE" && break
done

for ac_prog in unzip
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_UNZIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$UNZIP"; then
  ac_cv_prog_UNZIP="$UNZIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_UNZIP="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
UNZIP=$ac_cv_prog_UNZIP
if test -n "$UNZIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
$as_echo "$UNZIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$UNZIP" && break
done

for ac_prog in tar
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_TAR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$TAR"; then
  ac_cv_prog_TAR="$TAR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_TAR="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
TAR=$ac_cv_prog_TAR
if test -n "$TAR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
$as_echo "$TAR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$TAR" && break
done

for ac_prog in mkdir
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MKDIR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MKDIR"; then
  ac_cv_prog_MKDIR="$MKDIR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MKDIR="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MKDIR=$ac_cv_prog_MKDIR
if test -n "$MKDIR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
$as_echo "$MKDIR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$MKDIR" && break
done

for ac_prog in cp
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CP"; then
  ac_cv_prog_CP="$CP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CP="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CP=$ac_cv_prog_CP
if test -n "$CP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
$as_echo "$CP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$CP" && break
done

for ac_prog in rm
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_RM+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$RM"; then
  ac_cv_prog_RM="$RM" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_RM="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
RM=$ac_cv_prog_RM
if test -n "$RM"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
$as_echo "$RM" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$RM" && break
done

for ac_prog in stow
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STOW+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STOW"; then
  ac_cv_prog_STOW="$STOW" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STOW="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STOW=$ac_cv_prog_STOW
if test -n "$STOW"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STOW" >&5
$as_echo "$STOW" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$STOW" && break
done

for ac_prog in makensis
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MAKENSIS+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MAKENSIS"; then
  ac_cv_prog_MAKENSIS="$MAKENSIS" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MAKENSIS="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MAKENSIS=$ac_cv_prog_MAKENSIS
if test -n "$MAKENSIS"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAKENSIS" >&5
$as_echo "$MAKENSIS" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$MAKENSIS" && break
done

for ac_prog in zcat
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ZCAT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ZCAT"; then
  ac_cv_prog_ZCAT="$ZCAT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ZCAT="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ZCAT=$ac_cv_prog_ZCAT
if test -n "$ZCAT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZCAT" >&5
$as_echo "$ZCAT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ZCAT" && break
done

for ac_prog in texi2dvi
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_TEXI2DVI+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$TEXI2DVI"; then
  ac_cv_prog_TEXI2DVI="$TEXI2DVI" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_TEXI2DVI="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
TEXI2DVI=$ac_cv_prog_TEXI2DVI
if test -n "$TEXI2DVI"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEXI2DVI" >&5
$as_echo "$TEXI2DVI" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$TEXI2DVI" && break
done

for ac_prog in dvipdf
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_DVIPDF+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$DVIPDF"; then
  ac_cv_prog_DVIPDF="$DVIPDF" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_DVIPDF="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
DVIPDF=$ac_cv_prog_DVIPDF
if test -n "$DVIPDF"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DVIPDF" >&5
$as_echo "$DVIPDF" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$DVIPDF" && break
done

for ac_prog in convert
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CONVERT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CONVERT"; then
  ac_cv_prog_CONVERT="$CONVERT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CONVERT="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CONVERT=$ac_cv_prog_CONVERT
if test -n "$CONVERT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONVERT" >&5
$as_echo "$CONVERT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$CONVERT" && break
done

for ac_prog in sha1sum
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_SHA1SUM+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$SHA1SUM"; then
  ac_cv_prog_SHA1SUM="$SHA1SUM" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_SHA1SUM="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
SHA1SUM=$ac_cv_prog_SHA1SUM
if test -n "$SHA1SUM"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SHA1SUM" >&5
$as_echo "$SHA1SUM" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$SHA1SUM" && break
done

for ac_prog in msgfmt
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MSGFMT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MSGFMT"; then
  ac_cv_prog_MSGFMT="$MSGFMT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MSGFMT="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MSGFMT=$ac_cv_prog_MSGFMT
if test -n "$MSGFMT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5
$as_echo "$MSGFMT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$MSGFMT" && break
done

for ac_prog in msgmerge
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MSGFMT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MSGFMT"; then
  ac_cv_prog_MSGFMT="$MSGFMT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MSGFMT="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MSGFMT=$ac_cv_prog_MSGFMT
if test -n "$MSGFMT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5
$as_echo "$MSGFMT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$MSGFMT" && break
done

for ac_prog in gitlog-to-changelog
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_GITLOG_TO_CHANGELOG+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$GITLOG_TO_CHANGELOG"; then
  ac_cv_prog_GITLOG_TO_CHANGELOG="$GITLOG_TO_CHANGELOG" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_GITLOG_TO_CHANGELOG="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
GITLOG_TO_CHANGELOG=$ac_cv_prog_GITLOG_TO_CHANGELOG
if test -n "$GITLOG_TO_CHANGELOG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GITLOG_TO_CHANGELOG" >&5
$as_echo "$GITLOG_TO_CHANGELOG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$GITLOG_TO_CHANGELOG" && break
done
test -n "$GITLOG_TO_CHANGELOG" || GITLOG_TO_CHANGELOG="build-aux/gitlog-to-changelog"

for ac_prog in gcc cc
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_BUILD_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$BUILD_CC"; then
  ac_cv_prog_BUILD_CC="$BUILD_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_BUILD_CC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
BUILD_CC=$ac_cv_prog_BUILD_CC
if test -n "$BUILD_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
$as_echo "$BUILD_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$BUILD_CC" && break
done

for ac_prog in cmake3 cmake
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CMAKE+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CMAKE"; then
  ac_cv_prog_CMAKE="$CMAKE" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CMAKE="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CMAKE=$ac_cv_prog_CMAKE
if test -n "$CMAKE"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMAKE" >&5
$as_echo "$CMAKE" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$CMAKE" && break
done

for ac_prog in rsync
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_RSYNC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$RSYNC"; then
  ac_cv_prog_RSYNC="$RSYNC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_RSYNC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
RSYNC=$ac_cv_prog_RSYNC
if test -n "$RSYNC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RSYNC" >&5
$as_echo "$RSYNC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$RSYNC" && break
done

if test "${use_ninja}" = "yes"; then
    for ac_prog in ninja
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_NINJA+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$NINJA"; then
  ac_cv_prog_NINJA="$NINJA" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_NINJA="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
NINJA=$ac_cv_prog_NINJA
if test -n "$NINJA"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NINJA" >&5
$as_echo "$NINJA" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$NINJA" && break
done

    MAKETOOL=${NINJA}
    CMAKE_GENERATOR_FLAGS="-G Ninja -DCMAKE_GENERATOR=Ninja"
    { $as_echo "$as_me:${as_lineno-$LINENO}: Using ${NINJA} in cmake projects" >&5
$as_echo "$as_me: Using ${NINJA} in cmake projects" >&6;}
else
    MAKETOOL=${MAKE}
fi





if test -n "$GPGEX_ADD_HOST"; then
    if test -n "$ac_tool_prefix"; then
  for ac_prog in ${GPGEX_ADD_HOST}-strip
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP_EX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STRIP_EX"; then
  ac_cv_prog_STRIP_EX="$STRIP_EX" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STRIP_EX="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STRIP_EX=$ac_cv_prog_STRIP_EX
if test -n "$STRIP_EX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP_EX" >&5
$as_echo "$STRIP_EX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$STRIP_EX" && break
  done
fi
if test -z "$STRIP_EX"; then
  ac_ct_STRIP_EX=$STRIP_EX
  for ac_prog in ${GPGEX_ADD_HOST}-strip
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP_EX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_STRIP_EX"; then
  ac_cv_prog_ac_ct_STRIP_EX="$ac_ct_STRIP_EX" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_STRIP_EX="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_STRIP_EX=$ac_cv_prog_ac_ct_STRIP_EX
if test -n "$ac_ct_STRIP_EX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP_EX" >&5
$as_echo "$ac_ct_STRIP_EX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_STRIP_EX" && break
done

  if test "x$ac_ct_STRIP_EX" = x; then
    STRIP_EX=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    STRIP_EX=$ac_ct_STRIP_EX
  fi
fi

fi

if test -z "$GPG4WIN_PARALLEL"; then
    JOBS=$(nproc 2>/dev/null || echo 1)
    GPG4WIN_PARALLEL=-j$JOBS
    { $as_echo "$as_me:${as_lineno-$LINENO}: Using autodetected $JOBS make jobs. You can override this by setting GPG4WIN_PARALLEL." >&5
$as_echo "$as_me: Using autodetected $JOBS make jobs. You can override this by setting GPG4WIN_PARALLEL." >&6;}
fi


required_tools="MAKE TAR MKDIR CP RM ZCAT SHA1SUM MSGFMT BUILD_CC CMAKE"
if test "$build_gpg4win" = yes ; then
    required_tools="$required_tools DLLTOOL UNZIP STOW MAKENSIS TEXI2DVI DVIPDF CONVERT"
fi
if test "$build_appimage" = yes ; then
    required_tools="$required_tools RSYNC"
fi

missing_tools=
for i in $required_tools; do
   eval tmp='$'$i
   if test -z "$tmp"; then
      missing_tools="$missing_tools `echo $i | tr 'A-Z' 'a-z'`"
   fi
done

if test "$build_gpg4win" = yes ; then

    case "${host}" in
    x86_64*-mingw32*)
        BUILD_W64=yes
        # Since we use 32 makensis we need to compile our plugin
        # for NSIS also for 32bit so we hardcode this here.
        # Otherwise for 64 bit builds --with-additional-gpgex-host
        # is then 32 bit to take care of that.
        for ac_prog in i686-w64-mingw32-gcc
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_W32CC32+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$W32CC32"; then
  ac_cv_prog_W32CC32="$W32CC32" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_W32CC32="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
W32CC32=$ac_cv_prog_W32CC32
if test -n "$W32CC32"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $W32CC32" >&5
$as_echo "$W32CC32" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$W32CC32" && break
done


    dll_path="no"

# Check whether --with-libgcc_s_seh-1 was given.
if test "${with_libgcc_s_seh_1+set}" = set; then :
  withval=$with_libgcc_s_seh_1; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major=$($CC -dumpversion)

        guesses="/usr/lib/gcc/$host/$gcc_major_minor/libgcc_s_seh-1.dll
                 /usr/lib/gcc/$host/${gcc_major}/libgcc_s_seh-1.dll
                 /usr/$host/bin/libgcc_s_seh-1.dll
                 /usr/$host/lib/libgcc_s_seh-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor}-posix/libgcc_s_seh-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}-posix/libgcc_s_seh-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}/libgcc_s_seh-1.dll
                 /usr/$host/sys-root/mingw/bin/libgcc_s_seh-1.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the runtime library libgcc_s_seh-1.dll in the default locations.
                     Use the --with-libgcc_s_seh-1-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libgcc_s_seh-1.dll" >&5
$as_echo "$as_me: Using dummy for libgcc_s_seh-1.dll" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libgcc_s_seh-1.dll" >&5
$as_echo "$as_me: Using $dll_path to provide libgcc_s_seh-1.dll" >&6;}
    fi
    gpg4win_rtlib_libgcc_s_seh_1="$dll_path"


        ;;
    *)
        W32CC32=${CC}
        BUILD_W64=no
        ;;
    esac



    dll_path="no"

# Check whether --with-libstdc++-6 was given.
if test "${with_libstdc___6+set}" = set; then :
  withval=$with_libstdc___6; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major=$($CC -dumpversion)

        guesses="/usr/lib/gcc/$host/$gcc_major_minor/libstdc++-6.dll
                 /usr/lib/gcc/$host/${gcc_major}/libstdc++-6.dll
                 /usr/$host/bin/libstdc++-6.dll
                 /usr/$host/lib/libstdc++-6.dll
                 /usr/lib/gcc/$host/${gcc_major_minor}-posix/libstdc++-6.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}-posix/libstdc++-6.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}/libstdc++-6.dll
                 /usr/$host/sys-root/mingw/bin/libstdc++-6.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "REQUIRED" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the runtime library libstdc++-6.dll in the default locations.
                     Use the --with-libstdc++-6-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libstdc++-6.dll" >&5
$as_echo "$as_me: Using dummy for libstdc++-6.dll" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libstdc++-6.dll" >&5
$as_echo "$as_me: Using $dll_path to provide libstdc++-6.dll" >&6;}
    fi
    gpg4win_rtlib_libstdc___6="$dll_path"



    dll_path="no"

# Check whether --with-libwinpthread-1 was given.
if test "${with_libwinpthread_1+set}" = set; then :
  withval=$with_libwinpthread_1; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major=$($CC -dumpversion)

        guesses="/usr/lib/gcc/$host/$gcc_major_minor/libwinpthread-1.dll
                 /usr/lib/gcc/$host/${gcc_major}/libwinpthread-1.dll
                 /usr/$host/bin/libwinpthread-1.dll
                 /usr/$host/lib/libwinpthread-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor}-posix/libwinpthread-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}-posix/libwinpthread-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}/libwinpthread-1.dll
                 /usr/$host/sys-root/mingw/bin/libwinpthread-1.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "REQUIRED" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the runtime library libwinpthread-1.dll in the default locations.
                     Use the --with-libwinpthread-1-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libwinpthread-1.dll" >&5
$as_echo "$as_me: Using dummy for libwinpthread-1.dll" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libwinpthread-1.dll" >&5
$as_echo "$as_me: Using $dll_path to provide libwinpthread-1.dll" >&6;}
    fi
    gpg4win_rtlib_libwinpthread_1="$dll_path"




    dll_path="no"

# Check whether --with-libwinpthread-1 was given.
if test "${with_libwinpthread_1+set}" = set; then :
  withval=$with_libwinpthread_1; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')

        guesses="/usr/lib/gcc/$gpgex_host/$gcc_major_minor/libwinpthread-1.dll
                 /usr/$gpgex_host/bin/libwinpthread-1.dll
                 /usr/$gpgex_host/lib/libwinpthread-1.dll
                 /usr/lib/gcc/$gpgex_host/${gcc_major_minor}-posix/libwinpthread-1.dll
                 /usr/lib/gcc/$gpgex_host/${gcc_major_minor_alt}-posix/libwinpthread-1.dll
                 /usr/lib/gcc/$gpgex_host/${gcc_major_minor_alt}/libwinpthread-1.dll
                 /usr/$gpgex_host/sys-root/mingw/bin/libwinpthread-1.dll
                 /usr/lib/gcc/$gpgex_host/10-posix/libwinpthread-1.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the ex runtime library libwinpthread-1.dll in the default locations.
                     Use the --with-ex-libwinpthread-1-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libwinpthread-1.dll for $gpgex_host" >&5
$as_echo "$as_me: Using dummy for libwinpthread-1.dll for $gpgex_host" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libwinpthread-1.dll for $gpgex_host" >&5
$as_echo "$as_me: Using $dll_path to provide libwinpthread-1.dll for $gpgex_host" >&6;}
    fi
    gpg4win_rtlib_ex_libwinpthread_1="$dll_path"



    # One of these is required

    dll_path="no"

# Check whether --with-libgcc_s_dw2-1 was given.
if test "${with_libgcc_s_dw2_1+set}" = set; then :
  withval=$with_libgcc_s_dw2_1; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major=$($CC -dumpversion)

        guesses="/usr/lib/gcc/$host/$gcc_major_minor/libgcc_s_dw2-1.dll
                 /usr/lib/gcc/$host/${gcc_major}/libgcc_s_dw2-1.dll
                 /usr/$host/bin/libgcc_s_dw2-1.dll
                 /usr/$host/lib/libgcc_s_dw2-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor}-posix/libgcc_s_dw2-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}-posix/libgcc_s_dw2-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}/libgcc_s_dw2-1.dll
                 /usr/$host/sys-root/mingw/bin/libgcc_s_dw2-1.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the runtime library libgcc_s_dw2-1.dll in the default locations.
                     Use the --with-libgcc_s_dw2-1-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libgcc_s_dw2-1.dll" >&5
$as_echo "$as_me: Using dummy for libgcc_s_dw2-1.dll" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libgcc_s_dw2-1.dll" >&5
$as_echo "$as_me: Using $dll_path to provide libgcc_s_dw2-1.dll" >&6;}
    fi
    gpg4win_rtlib_libgcc_s_dw2_1="$dll_path"



    dll_path="no"

# Check whether --with-libgcc_s_sjlj-1 was given.
if test "${with_libgcc_s_sjlj_1+set}" = set; then :
  withval=$with_libgcc_s_sjlj_1; dll_path=$withval
fi


    if test "$dll_path" = "no"; then

        gcc_major_minor=$($CC --version \
                          | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major_minor_alt=$($CC --version | cut -d " " -f 3 \
                             | awk 'NR==1 {split($NF,a,"."); print a[1] "." a[2]}')
        gcc_major=$($CC -dumpversion)

        guesses="/usr/lib/gcc/$host/$gcc_major_minor/libgcc_s_sjlj-1.dll
                 /usr/lib/gcc/$host/${gcc_major}/libgcc_s_sjlj-1.dll
                 /usr/$host/bin/libgcc_s_sjlj-1.dll
                 /usr/$host/lib/libgcc_s_sjlj-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor}-posix/libgcc_s_sjlj-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}-posix/libgcc_s_sjlj-1.dll
                 /usr/lib/gcc/$host/${gcc_major_minor_alt}/libgcc_s_sjlj-1.dll
                 /usr/$host/sys-root/mingw/bin/libgcc_s_sjlj-1.dll"

        for file in $guesses; do
            if test -r "$file"; then
                dll_path="$file"
                break
            fi
        done
    fi

    if test "" = "REQUIRED" -a "$dll_path" = "no"; then
        as_fn_error $? "can not find the runtime library libgcc_s_sjlj-1.dll in the default locations.
                     Use the --with-libgcc_s_sjlj-1-dll option to set the path directly.
        " "$LINENO" 5
    elif test "$dll_path" = no; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using dummy for libgcc_s_sjlj-1.dll" >&5
$as_echo "$as_me: Using dummy for libgcc_s_sjlj-1.dll" >&6;}
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: Using $dll_path to provide libgcc_s_sjlj-1.dll" >&5
$as_echo "$as_me: Using $dll_path to provide libgcc_s_sjlj-1.dll" >&6;}
    fi
    gpg4win_rtlib_libgcc_s_sjlj_1="$dll_path"



    if test "${gpg4win_rtlib_libgcc_s_dw2_1}" = no \
         -a "${gpg4win_rtlib_libgcc_s_sjlj_1}" = no \
         -a "${gpg4win_rtlib_libgcc_s_seh_1}" = no ; then
        as_fn_error $? "No exception library found. Please check what your system
                     uses and see above message about either dw2- sjlj- or seh-
                     dlls." "$LINENO" 5
    fi
fi

for ac_prog in wget
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_WGET+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$WGET"; then
  ac_cv_prog_WGET="$WGET" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_WGET="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
WGET=$ac_cv_prog_WGET
if test -n "$WGET"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WGET" >&5
$as_echo "$WGET" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$WGET" && break
done



#
# Set source and build directory.
#
# They are always set to the directories seen outside of the
# container.
#
TOPSRCDIR="/home/builder/s/gpg4win"

# Check whether --with-playground was given.
if test "${with_playground+set}" = set; then :
  withval=$with_playground; PLAYGROUND="$withval"
else
  PLAYGROUND=""
fi


if test -n "$PLAYGROUND" ; then
    if test ! -d "$PLAYGROUND"; then
        as_fn_error $? "
***
*** Given playground directory does not exist.
*** Please create it first or use the default.
***" "$LINENO" 5
    fi
    PLAYGROUND="$(cd "$PLAYGROUND" && pwd)"
else
    PLAYGROUND="${HOME}/b/$(basename "$TOPSRCDIR")-playground"
fi
PLAYGROUND=$(echo "$PLAYGROUND" | sed s,^//,/,)




#
# Prepare variables for po/Makefile.am
# Note that we do not use the ususal GNU gettext make system.
#
# LINGUAS  := The list of all translated languages taken from po/LINGUAS
# POTFILES := The list of NSI files with translatable strings taken from
#             po/POTFILES
# POFILES  := The actual available translations (w/o directory)
# NSIFILES := The to-be generated translation files in the NSI format.
#             (w/o directory)
#
if test $dockerbuild = yes ; then
  posrcdir=/src/po
else
  posrcdir="$TOPSRCDIR/po"
fi
LINGUAS=$(sed -e "/^#/d" -e "s/#.*//" "$posrcdir/LINGUAS" | xargs -- )
POTFILES=$(for f in $(sed -e "/^#/d" -e "s/#.*//" "$posrcdir/POTFILES");\
           do echo "$posrcdir/$f"; done | xargs -- )


POFILES=
NSIFILES=
for lang in $LINGUAS; do
   if test -f "$posrcdir/$lang.po" ; then
       POFILES="$POFILES $lang.po"
       NSIFILES="$NSIFILES $lang.nsi"
   fi
done




#
# Packages for Gpg4Win.
#
if test "$build_gpg4win" = yes ; then
    gpg4win_dup_sources=""


  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for packages directory" >&5
$as_echo_n "checking for packages directory... " >&6; }
  if test -f /src/packages/BUILDTYPE; then :
  _gpg4win_packages_default=/src/packages
else
  _gpg4win_packages_default=packages
fi

# Check whether --with-packages was given.
if test "${with_packages+set}" = set; then :
  withval=$with_packages; gpg4win_packages=$withval
fi

  if test -z $gpg4win_packages; then :
  gpg4win_packages=$_gpg4win_packages_default
fi
  if test `echo $gpg4win_packages | head -c 1` != /; then :
  gpg4win_packages=`pwd`/$gpg4win_packages
fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gpg4win_packages" >&5
$as_echo "$gpg4win_packages" >&6; }

  # Set auto-detection.  FIXME: This should accept a comma-separated
  # list of packages that will be autodetected.
  _gpg4win_auto_detection=yes
  # Check whether --enable-packages was given.
if test "${enable_packages+set}" = set; then :
  enableval=$enable_packages; _gpg4win_auto_detection=$enableval
fi



  # We call this here so its options appear before the per-package options.



  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Bash" >&5
$as_echo_n "checking for Bash... " >&6; }
  _bash=$BASH_VERSION
  if test -z "$_bash"; then
    _bash=no
  fi
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_bash" >&5
$as_echo "$_bash" >&6; }
  if test $_bash = no; then
    as_fn_error $? "\"this configure script requires Bash\"" "$LINENO" 5
  fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-zlib was given.
if test "${enable_pkg_zlib+set}" = set; then :
  enableval=$enable_pkg_zlib; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package zlib" >&5
$as_echo_n "checking for package zlib... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='zlib-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for zlib in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for zlib in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for zlib in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources zlib";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_zlib=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_zlib_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_zlib_deps=""


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs zlib"

  eval HAVE_PKG_ZLIB=\"\!define HAVE_PKG_ZLIB 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps zlib zlib"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i zlib"
          done
fi

fi




  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-pkgconfig was given.
if test "${enable_pkg_pkgconfig+set}" = set; then :
  enableval=$enable_pkg_pkgconfig; _gpg4win_pkg=$enableval
fi

  _gpg4win_bpkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pkgconfig" >&5
$as_echo_n "checking for package pkgconfig... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='pkgconfig-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z "zip"; then :
  _gpg4win_format="zip"
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for pkgconfig in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pkgconfig in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pkgconfig in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources pkgconfig";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_bpkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_BINARY
  gpg4win_pkg_pkgconfig=$_gpg4win_bpkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_pkgconfig_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_pkgconfig_deps=""


  if test "$_gpg4win_bpkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pkgconfig" >&5
$as_echo_n "checking for package pkgconfig... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='pkgconfig-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z "tar"; then :
  _gpg4win_format="tar"
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for pkgconfig in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pkgconfig in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pkgconfig in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources pkgconfig";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
else
  as_fn_error $? "can not find sources for package pkgconfig" "$LINENO" 5
fi

    # gpg4win_pkg_PKGNAME_src=FILENAME_OF_SOURCE
    gpg4win_pkg_pkgconfig_src=$_gpg4win_bpkg


    # FIXME: Add a version consistency check here.  All three packages
    # must match!


  eval HAVE_PKG_PKGCONFIG=\"\!define HAVE_PKG_PKGCONFIG 1\"



    _gpg4win_pkgs="$_gpg4win_pkgs pkgconfig"
    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps pkgconfig pkgconfig"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
	    _gpg4win_deps="$_gpg4win_deps $_gpg4win_i pkgconfig"
          done
fi

fi




  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-bzip2 was given.
if test "${enable_pkg_bzip2+set}" = set; then :
  enableval=$enable_pkg_bzip2; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package bzip2" >&5
$as_echo_n "checking for package bzip2... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='bzip2-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for bzip2 in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for bzip2 in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for bzip2 in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources bzip2";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_bzip2=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_bzip2_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_bzip2_deps=""


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs bzip2"

  eval HAVE_PKG_BZIP2=\"\!define HAVE_PKG_BZIP2 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps bzip2 bzip2"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i bzip2"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libgpg-error was given.
if test "${enable_pkg_libgpg_error+set}" = set; then :
  enableval=$enable_pkg_libgpg_error; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libgpg-error" >&5
$as_echo_n "checking for package libgpg-error... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libgpg-error-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libgpg-error in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libgpg-error in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libgpg-error in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libgpg-error";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libgpg_error=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libgpg_error_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libgpg_error_deps="libiconv gettext"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libgpg-error"

  eval HAVE_PKG_LIBGPG_ERROR=\"\!define HAVE_PKG_LIBGPG_ERROR 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libgpg-error libgpg-error"
    if test ! -z "libiconv gettext"; then :
  for _gpg4win_i in libiconv gettext; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libgpg-error"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libassuan was given.
if test "${enable_pkg_libassuan+set}" = set; then :
  enableval=$enable_pkg_libassuan; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libassuan" >&5
$as_echo_n "checking for package libassuan... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libassuan-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libassuan in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libassuan in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libassuan in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libassuan";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libassuan=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libassuan_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libassuan_deps="libgpg-error"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libassuan"

  eval HAVE_PKG_LIBASSUAN=\"\!define HAVE_PKG_LIBASSUAN 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libassuan libassuan"
    if test ! -z "libgpg-error"; then :
  for _gpg4win_i in libgpg-error; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libassuan"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-scute was given.
if test "${enable_pkg_scute+set}" = set; then :
  enableval=$enable_pkg_scute; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package scute" >&5
$as_echo_n "checking for package scute... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='scute-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for scute in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for scute in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for scute in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources scute";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_scute=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_scute_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_scute_deps="libgpg-error libassuan"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs scute"

  eval HAVE_PKG_SCUTE=\"\!define HAVE_PKG_SCUTE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps scute scute"
    if test ! -z "libgpg-error libassuan"; then :
  for _gpg4win_i in libgpg-error libassuan; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i scute"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-pinentry was given.
if test "${enable_pkg_pinentry+set}" = set; then :
  enableval=$enable_pkg_pinentry; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pinentry" >&5
$as_echo_n "checking for package pinentry... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='pinentry-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for pinentry in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pinentry in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pinentry in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources pinentry";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_pinentry=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_pinentry_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_pinentry_deps="qtbase libassuan libiconv"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs pinentry"

  eval HAVE_PKG_PINENTRY=\"\!define HAVE_PKG_PINENTRY 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps pinentry pinentry"
    if test ! -z "qtbase libassuan libiconv"; then :
  for _gpg4win_i in qtbase libassuan libiconv; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i pinentry"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgme was given.
if test "${enable_pkg_gpgme+set}" = set; then :
  enableval=$enable_pkg_gpgme; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgme" >&5
$as_echo_n "checking for package gpgme... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgme-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgme in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgme in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgme in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgme";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgme=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgme_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgme_deps="libgpg-error libassuan"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgme"

  eval HAVE_PKG_GPGME=\"\!define HAVE_PKG_GPGME 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgme gpgme"
    if test ! -z "libgpg-error libassuan"; then :
  for _gpg4win_i in libgpg-error libassuan; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgme"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgmepp was given.
if test "${enable_pkg_gpgmepp+set}" = set; then :
  enableval=$enable_pkg_gpgmepp; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgmepp" >&5
$as_echo_n "checking for package gpgmepp... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgmepp-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgmepp in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgmepp in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgmepp in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgmepp";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgmepp=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgmepp_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgmepp_deps="gpgme"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgmepp"

  eval HAVE_PKG_GPGMEPP=\"\!define HAVE_PKG_GPGMEPP 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgmepp gpgmepp"
    if test ! -z "gpgme"; then :
  for _gpg4win_i in gpgme; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgmepp"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qgpgme was given.
if test "${enable_pkg_qgpgme+set}" = set; then :
  enableval=$enable_pkg_qgpgme; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qgpgme" >&5
$as_echo_n "checking for package qgpgme... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qgpgme-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qgpgme in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qgpgme in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qgpgme in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qgpgme";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qgpgme=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qgpgme_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qgpgme_deps="gpgmepp qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qgpgme"

  eval HAVE_PKG_QGPGME=\"\!define HAVE_PKG_QGPGME 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qgpgme qgpgme"
    if test ! -z "gpgmepp qtbase"; then :
  for _gpg4win_i in gpgmepp qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qgpgme"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgol was given.
if test "${enable_pkg_gpgol+set}" = set; then :
  enableval=$enable_pkg_gpgol; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgol" >&5
$as_echo_n "checking for package gpgol... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgol-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgol in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgol in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgol in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgol";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgol=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgol_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgol_deps="gpgmepp libassuan"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgol"

  eval HAVE_PKG_GPGOL=\"\!define HAVE_PKG_GPGOL 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgol gpgol"
    if test ! -z "gpgmepp libassuan"; then :
  for _gpg4win_i in gpgmepp libassuan; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgol"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgex was given.
if test "${enable_pkg_gpgex+set}" = set; then :
  enableval=$enable_pkg_gpgex; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgex" >&5
$as_echo_n "checking for package gpgex... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgex-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgex in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgex in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgex in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgex";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgex=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgex_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgex_deps="libassuan"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgex"

  eval HAVE_PKG_GPGEX=\"\!define HAVE_PKG_GPGEX 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgex gpgex"
    if test ! -z "libassuan"; then :
  for _gpg4win_i in libassuan; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgex"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-paperkey was given.
if test "${enable_pkg_paperkey+set}" = set; then :
  enableval=$enable_pkg_paperkey; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package paperkey" >&5
$as_echo_n "checking for package paperkey... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='paperkey-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for paperkey in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for paperkey in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for paperkey in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources paperkey";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_paperkey=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_paperkey_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_paperkey_deps=""


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs paperkey"

  eval HAVE_PKG_PAPERKEY=\"\!define HAVE_PKG_PAPERKEY 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps paperkey paperkey"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i paperkey"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libiconv was given.
if test "${enable_pkg_libiconv+set}" = set; then :
  enableval=$enable_pkg_libiconv; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libiconv" >&5
$as_echo_n "checking for package libiconv... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libiconv-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libiconv in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libiconv in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libiconv in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libiconv";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libiconv=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libiconv_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libiconv_deps=""


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libiconv"

  eval HAVE_PKG_LIBICONV=\"\!define HAVE_PKG_LIBICONV 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libiconv libiconv"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libiconv"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gettext was given.
if test "${enable_pkg_gettext+set}" = set; then :
  enableval=$enable_pkg_gettext; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gettext" >&5
$as_echo_n "checking for package gettext... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gettext-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gettext in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gettext in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gettext in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gettext";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gettext=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gettext_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gettext_deps="libiconv"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gettext"

  eval HAVE_PKG_GETTEXT=\"\!define HAVE_PKG_GETTEXT 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gettext gettext"
    if test ! -z "libiconv"; then :
  for _gpg4win_i in libiconv; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gettext"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libpng was given.
if test "${enable_pkg_libpng+set}" = set; then :
  enableval=$enable_pkg_libpng; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libpng" >&5
$as_echo_n "checking for package libpng... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libpng-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libpng in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libpng in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libpng in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libpng";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libpng=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libpng_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libpng_deps="zlib"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libpng"

  eval HAVE_PKG_LIBPNG=\"\!define HAVE_PKG_LIBPNG 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libpng libpng"
    if test ! -z "zlib"; then :
  for _gpg4win_i in zlib; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libpng"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-jpeg was given.
if test "${enable_pkg_jpeg+set}" = set; then :
  enableval=$enable_pkg_jpeg; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package jpeg" >&5
$as_echo_n "checking for package jpeg... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='jpeg-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for jpeg in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for jpeg in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for jpeg in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources jpeg";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_jpeg=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_jpeg_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_jpeg_deps=""


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs jpeg"

  eval HAVE_PKG_JPEG=\"\!define HAVE_PKG_JPEG 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps jpeg jpeg"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i jpeg"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qrencode was given.
if test "${enable_pkg_qrencode+set}" = set; then :
  enableval=$enable_pkg_qrencode; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qrencode" >&5
$as_echo_n "checking for package qrencode... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qrencode-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qrencode in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qrencode in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qrencode in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qrencode";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qrencode=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qrencode_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qrencode_deps="libpng libiconv"


  if test "$_gpg4win_spkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qrencode"

  eval HAVE_PKG_QRENCODE=\"\!define HAVE_PKG_QRENCODE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qrencode qrencode"
    if test ! -z "libpng libiconv"; then :
  for _gpg4win_i in libpng libiconv; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qrencode"
          done
fi

fi


    # Packages needed for gpgex


  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libgpg-error was given.
if test "${enable_pkg_libgpg_error+set}" = set; then :
  enableval=$enable_pkg_libgpg_error; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libgpg-error" >&5
$as_echo_n "checking for package libgpg-error... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libgpg-error-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libgpg-error in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libgpg-error in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libgpg-error in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libgpg-error";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libgpg_error=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libgpg_error_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_libgpg_error_ex_deps=""


    if test "$_gpg4win_spkg" != no; then :
  gpg4win_ex_pkgs="$gpg4win_ex_pkgs libgpg-error"


  eval HAVE_PKG_LIBGPG_ERROR_EX=\"\!define HAVE_PKG_LIBGPG_ERROR_EX 1\"


      # Record dependencies.  Also enter every package as node.
      _gpg4win_ex_deps="$_gpg4win_ex_deps libgpg-error libgpg-error"
      if test ! -z ""; then :
  for _gpg4win_i in ; do
              _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i libgpg-error"
            done
fi

fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libassuan was given.
if test "${enable_pkg_libassuan+set}" = set; then :
  enableval=$enable_pkg_libassuan; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libassuan" >&5
$as_echo_n "checking for package libassuan... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libassuan-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libassuan in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libassuan in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libassuan in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libassuan";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libassuan=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libassuan_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_libassuan_ex_deps="libgpg-error"


    if test "$_gpg4win_spkg" != no; then :
  gpg4win_ex_pkgs="$gpg4win_ex_pkgs libassuan"


  eval HAVE_PKG_LIBASSUAN_EX=\"\!define HAVE_PKG_LIBASSUAN_EX 1\"


      # Record dependencies.  Also enter every package as node.
      _gpg4win_ex_deps="$_gpg4win_ex_deps libassuan libassuan"
      if test ! -z "libgpg-error"; then :
  for _gpg4win_i in libgpg-error; do
              _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i libassuan"
            done
fi

fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgex was given.
if test "${enable_pkg_gpgex+set}" = set; then :
  enableval=$enable_pkg_gpgex; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgex" >&5
$as_echo_n "checking for package gpgex... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgex-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgex in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgex in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgex in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgex";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgex=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgex_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_gpgex_ex_deps="libassuan"


    if test "$_gpg4win_spkg" != no; then :
  gpg4win_ex_pkgs="$gpg4win_ex_pkgs gpgex"


  eval HAVE_PKG_GPGEX_EX=\"\!define HAVE_PKG_GPGEX_EX 1\"


      # Record dependencies.  Also enter every package as node.
      _gpg4win_ex_deps="$_gpg4win_ex_deps gpgex gpgex"
      if test ! -z "libassuan"; then :
  for _gpg4win_i in libassuan; do
              _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i gpgex"
            done
fi

fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgme was given.
if test "${enable_pkg_gpgme+set}" = set; then :
  enableval=$enable_pkg_gpgme; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgme" >&5
$as_echo_n "checking for package gpgme... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgme-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgme in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgme in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgme in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgme";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgme=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgme_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_gpgme_ex_deps="libgpg-error libassuan"


    if test "$_gpg4win_spkg" != no; then :
  gpg4win_ex_pkgs="$gpg4win_ex_pkgs gpgme"


  eval HAVE_PKG_GPGME_EX=\"\!define HAVE_PKG_GPGME_EX 1\"


      # Record dependencies.  Also enter every package as node.
      _gpg4win_ex_deps="$_gpg4win_ex_deps gpgme gpgme"
      if test ! -z "libgpg-error libassuan"; then :
  for _gpg4win_i in libgpg-error libassuan; do
              _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i gpgme"
            done
fi

fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgmepp was given.
if test "${enable_pkg_gpgmepp+set}" = set; then :
  enableval=$enable_pkg_gpgmepp; _gpg4win_pkg=$enableval
fi

  _gpg4win_cmkpkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgmepp" >&5
$as_echo_n "checking for package gpgmepp... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgmepp-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgmepp in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgmepp in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgmepp in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgmepp";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_cmkpkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgmepp=$_gpg4win_cmkpkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgmepp_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_gpgmepp_ex_deps="gpgme"


    _gpg4win_ex_pkgs="$_gpg4win_ex_pkgs gpgmepp"


  eval HAVE_PKG_GPGMEPP=\"\!define HAVE_PKG_GPGMEPP 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_ex_deps="$_gpg4win_ex_deps gpgmepp gpgmepp"
    if test ! -z "gpgme"; then :
  for _gpg4win_i in gpgme; do
            _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i gpgmepp"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgol was given.
if test "${enable_pkg_gpgol+set}" = set; then :
  enableval=$enable_pkg_gpgol; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgol" >&5
$as_echo_n "checking for package gpgol... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgol-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgol in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgol in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgol in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgol";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgol=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgol_version=$_gpg4win_version


  if test ! -z "$GPGEX_ADD_HOST"; then :
  # gpg4win_pkg_PKGNAME_deps=DEPS
    gpg4win_pkg_gpgol_ex_deps="gpgmepp"


    if test "$_gpg4win_spkg" != no; then :
  gpg4win_ex_pkgs="$gpg4win_ex_pkgs gpgol"


  eval HAVE_PKG_GPGOL_EX=\"\!define HAVE_PKG_GPGOL_EX 1\"


      # Record dependencies.  Also enter every package as node.
      _gpg4win_ex_deps="$_gpg4win_ex_deps gpgol gpgol"
      if test ! -z "gpgmepp"; then :
  for _gpg4win_i in gpgmepp; do
              _gpg4win_ex_deps="$_gpg4win_ex_deps $_gpg4win_i gpgol"
            done
fi

fi

fi


    # The GnuPG Package.


  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gnupg-w32 was given.
if test "${enable_pkg_gnupg_w32+set}" = set; then :
  enableval=$enable_pkg_gnupg_w32; _gpg4win_pkg=$enableval
fi

  _gpg4win_bpkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-w32-bin" >&5
$as_echo_n "checking for package gnupg-w32-bin... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-w32-\(.*\)-bin"; then :
  _gpg4win_pat='gnupg-w32-bin-\([0-9].*\)'
else
  _gpg4win_pat="gnupg-w32-\(.*\)-bin"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-w32-bin in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-w32-bin in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-w32-bin in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-w32-bin";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  if test "$_gpg4win_pkg" != no -a "$_gpg4win_bpkg" = no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-w32-noinstaller" >&5
$as_echo_n "checking for package gnupg-w32-noinstaller... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-w32-\(.*\)-noinstaller"; then :
  _gpg4win_pat='gnupg-w32-noinstaller-\([0-9].*\)'
else
  _gpg4win_pat="gnupg-w32-\(.*\)-noinstaller"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-w32-noinstaller in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-w32-noinstaller in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-w32-noinstaller in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-w32-noinstaller";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_bpkg is no, or the actual package binary file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_BINARY
  gpg4win_pkg_gnupg_w32=$_gpg4win_bpkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gnupg_w32_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gnupg_w32_deps=""


  if test "$_gpg4win_bpkg" != no; then :
  tmp_binsrc=yes




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-w32-src" >&5
$as_echo_n "checking for package gnupg-w32-src... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-w32-\(.*\)-src"; then :
  _gpg4win_pat='gnupg-w32-src-\(0-9.*\)'
else
  _gpg4win_pat="gnupg-w32-\(.*\)-src"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-w32-src in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-w32-src in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-w32-src in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-w32-src";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
else
  tmp_binsrc=no
fi

    if test $tmp_binsrc = no ; then




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-w32-source" >&5
$as_echo_n "checking for package gnupg-w32-source... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-w32-\(.*\)-source"; then :
  _gpg4win_pat='gnupg-w32-source-\(0-9.*\)'
else
  _gpg4win_pat="gnupg-w32-\(.*\)-source"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-w32-source in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-w32-source in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-w32-source in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-w32-source";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
else
  as_fn_error $? "can not find sources for package gnupg-w32" "$LINENO" 5
fi

    fi
    # gpg4win_pkg_PKGNAME_src=FILENAME_OF_SOURCE
    gpg4win_pkg_gnupg_w32_src=$_gpg4win_bpkg


    # FIXME: Add a version consistency check here.  Both packages
    # must match!


  eval HAVE_PKG_GNUPG_W32=\"\!define HAVE_PKG_GNUPG_W32 1\"



    _gpg4win_pkgs="$_gpg4win_pkgs gnupg-w32"
    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gnupg-w32 gnupg-w32"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
	    _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gnupg-w32"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gnupg-msi was given.
if test "${enable_pkg_gnupg_msi+set}" = set; then :
  enableval=$enable_pkg_gnupg_msi; _gpg4win_pkg=$enableval
fi

  _gpg4win_bpkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-msi-bin" >&5
$as_echo_n "checking for package gnupg-msi-bin... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-msi-\(.*\)-bin"; then :
  _gpg4win_pat='gnupg-msi-bin-\([0-9].*\)'
else
  _gpg4win_pat="gnupg-msi-\(.*\)-bin"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-msi-bin in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-msi-bin in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-msi-bin in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-msi-bin";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  if test "$_gpg4win_pkg" != no -a "$_gpg4win_bpkg" = no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-msi-noinstaller" >&5
$as_echo_n "checking for package gnupg-msi-noinstaller... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-msi-\(.*\)-noinstaller"; then :
  _gpg4win_pat='gnupg-msi-noinstaller-\([0-9].*\)'
else
  _gpg4win_pat="gnupg-msi-\(.*\)-noinstaller"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-msi-noinstaller in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-msi-noinstaller in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-msi-noinstaller in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-msi-noinstaller";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi

  # At this point, _gpg4win_bpkg is no, or the actual package binary file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_BINARY
  gpg4win_pkg_gnupg_msi=$_gpg4win_bpkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gnupg_msi_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gnupg_msi_deps=""


  if test "$_gpg4win_bpkg" != no; then :
  tmp_binsrc=yes




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-msi-src" >&5
$as_echo_n "checking for package gnupg-msi-src... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-msi-\(.*\)-src"; then :
  _gpg4win_pat='gnupg-msi-src-\(0-9.*\)'
else
  _gpg4win_pat="gnupg-msi-\(.*\)-src"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-msi-src in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-msi-src in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-msi-src in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-msi-src";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
else
  tmp_binsrc=no
fi

    if test $tmp_binsrc = no ; then




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg-msi-source" >&5
$as_echo_n "checking for package gnupg-msi-source... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z "gnupg-msi-\(.*\)-source"; then :
  _gpg4win_pat='gnupg-msi-source-\(0-9.*\)'
else
  _gpg4win_pat="gnupg-msi-\(.*\)-source"
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg-msi-source in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg-msi-source in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg-msi-source in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gnupg-msi-source";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_bpkg=$gpg4win_val
else
  as_fn_error $? "can not find sources for package gnupg-msi" "$LINENO" 5
fi

    fi
    # gpg4win_pkg_PKGNAME_src=FILENAME_OF_SOURCE
    gpg4win_pkg_gnupg_msi_src=$_gpg4win_bpkg


  eval HAVE_PKG_GNUPG_MSI=\"\!define HAVE_PKG_GNUPG_MSI 1\"



fi


    # Tools required for cross compiling


  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qtbase was given.
if test "${enable_pkg_qtbase+set}" = set; then :
  enableval=$enable_pkg_qtbase; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtbase" >&5
$as_echo_n "checking for package qtbase... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qtbase-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qtbase in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtbase in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtbase in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qtbase";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qtbase=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qtbase_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qtbase_native_deps=""



  eval HAVE_PKG_QTBASE_NATIVE=\"\!define HAVE_PKG_QTBASE_NATIVE 1\"



  _gpg4win_pkgs="$_gpg4win_pkgs native-qtbase"

  # Record dependencies.  Also enter every package as node.
  _gpg4win_deps="$_gpg4win_deps native-qtbase native-qtbase"
  if test ! -z ""; then :
  for _gpg4win_i in ; do
          _gpg4win_deps="$_gpg4win_deps native-$_gpg4win_i native-qtbase"
        done
fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-extra-cmake-modules was given.
if test "${enable_pkg_extra_cmake_modules+set}" = set; then :
  enableval=$enable_pkg_extra_cmake_modules; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package extra-cmake-modules" >&5
$as_echo_n "checking for package extra-cmake-modules... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='extra-cmake-modules-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for extra-cmake-modules in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for extra-cmake-modules in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for extra-cmake-modules in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources extra-cmake-modules";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_extra_cmake_modules=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_extra_cmake_modules_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_extra_cmake_modules_native_deps=""



  eval HAVE_PKG_EXTRA_CMAKE_MODULES_NATIVE=\"\!define HAVE_PKG_EXTRA_CMAKE_MODULES_NATIVE 1\"



  _gpg4win_pkgs="$_gpg4win_pkgs native-extra-cmake-modules"

  # Record dependencies.  Also enter every package as node.
  _gpg4win_deps="$_gpg4win_deps native-extra-cmake-modules native-extra-cmake-modules"
  if test ! -z ""; then :
  for _gpg4win_i in ; do
          _gpg4win_deps="$_gpg4win_deps native-$_gpg4win_i native-extra-cmake-modules"
        done
fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-breeze-icons was given.
if test "${enable_pkg_breeze_icons+set}" = set; then :
  enableval=$enable_pkg_breeze_icons; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package breeze-icons" >&5
$as_echo_n "checking for package breeze-icons... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='breeze-icons-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for breeze-icons in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for breeze-icons in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for breeze-icons in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources breeze-icons";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_breeze_icons=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_breeze_icons_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_breeze_icons_native_deps="qtbase extra-cmake-modules"



  eval HAVE_PKG_BREEZE_ICONS_NATIVE=\"\!define HAVE_PKG_BREEZE_ICONS_NATIVE 1\"



  _gpg4win_pkgs="$_gpg4win_pkgs native-breeze-icons"

  # Record dependencies.  Also enter every package as node.
  _gpg4win_deps="$_gpg4win_deps native-breeze-icons native-breeze-icons"
  if test ! -z "qtbase extra-cmake-modules"; then :
  for _gpg4win_i in qtbase extra-cmake-modules; do
          _gpg4win_deps="$_gpg4win_deps native-$_gpg4win_i native-breeze-icons"
        done
fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qttools was given.
if test "${enable_pkg_qttools+set}" = set; then :
  enableval=$enable_pkg_qttools; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qttools" >&5
$as_echo_n "checking for package qttools... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qttools-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qttools in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qttools in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qttools in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qttools";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qttools=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qttools_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qttools_native_deps="qtbase"



  eval HAVE_PKG_QTTOOLS_NATIVE=\"\!define HAVE_PKG_QTTOOLS_NATIVE 1\"



  _gpg4win_pkgs="$_gpg4win_pkgs native-qttools"

  # Record dependencies.  Also enter every package as node.
  _gpg4win_deps="$_gpg4win_deps native-qttools native-qttools"
  if test ! -z "qtbase"; then :
  for _gpg4win_i in qtbase; do
          _gpg4win_deps="$_gpg4win_deps native-$_gpg4win_i native-qttools"
        done
fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kconfig was given.
if test "${enable_pkg_kconfig+set}" = set; then :
  enableval=$enable_pkg_kconfig; _gpg4win_pkg=$enableval
fi

  _gpg4win_spkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kconfig" >&5
$as_echo_n "checking for package kconfig... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kconfig-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kconfig in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kconfig in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kconfig in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kconfig";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_spkg=$gpg4win_val
	 _gpg4win_version=$gpg4win_version
fi

fi
  # At this point, _gpg4win_spkg is no, or the actual package source file.

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kconfig=$_gpg4win_spkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kconfig_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kconfig_native_deps="qtbase qttools extra-cmake-modules"



  eval HAVE_PKG_KCONFIG_NATIVE=\"\!define HAVE_PKG_KCONFIG_NATIVE 1\"



  _gpg4win_pkgs="$_gpg4win_pkgs native-kconfig"

  # Record dependencies.  Also enter every package as node.
  _gpg4win_deps="$_gpg4win_deps native-kconfig native-kconfig"
  if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase qttools extra-cmake-modules; do
          _gpg4win_deps="$_gpg4win_deps native-$_gpg4win_i native-kconfig"
        done
fi


    # Qt related stuff.


  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-zstd was given.
if test "${enable_pkg_zstd+set}" = set; then :
  enableval=$enable_pkg_zstd; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package zstd" >&5
$as_echo_n "checking for package zstd... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='zstd-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for zstd in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for zstd in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for zstd in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources zstd";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_zstd=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_zstd_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_zstd_deps=""


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs zstd"

  eval HAVE_PKG_ZSTD=\"\!define HAVE_PKG_ZSTD 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps zstd zstd"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i zstd"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qtbase was given.
if test "${enable_pkg_qtbase+set}" = set; then :
  enableval=$enable_pkg_qtbase; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtbase" >&5
$as_echo_n "checking for package qtbase... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qtbase-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qtbase in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtbase in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtbase in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qtbase";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qtbase=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qtbase_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qtbase_deps="jpeg zlib zstd libpng freetype pcre2"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qtbase"

  eval HAVE_PKG_QTBASE=\"\!define HAVE_PKG_QTBASE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qtbase qtbase"
    if test ! -z "jpeg zlib zstd libpng freetype pcre2"; then :
  for _gpg4win_i in jpeg zlib zstd libpng freetype pcre2; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qtbase"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qttools was given.
if test "${enable_pkg_qttools+set}" = set; then :
  enableval=$enable_pkg_qttools; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qttools" >&5
$as_echo_n "checking for package qttools... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qttools-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qttools in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qttools in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qttools in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qttools";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qttools=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qttools_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qttools_deps="qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qttools"

  eval HAVE_PKG_QTTOOLS=\"\!define HAVE_PKG_QTTOOLS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qttools qttools"
    if test ! -z "qtbase"; then :
  for _gpg4win_i in qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qttools"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qttranslations was given.
if test "${enable_pkg_qttranslations+set}" = set; then :
  enableval=$enable_pkg_qttranslations; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qttranslations" >&5
$as_echo_n "checking for package qttranslations... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qttranslations-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qttranslations in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qttranslations in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qttranslations in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qttranslations";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qttranslations=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qttranslations_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qttranslations_deps="qtsvg qttools native-qttools"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qttranslations"

  eval HAVE_PKG_QTTRANSLATIONS=\"\!define HAVE_PKG_QTTRANSLATIONS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qttranslations qttranslations"
    if test ! -z "qtsvg qttools native-qttools"; then :
  for _gpg4win_i in qtsvg qttools native-qttools; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qttranslations"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qtsvg was given.
if test "${enable_pkg_qtsvg+set}" = set; then :
  enableval=$enable_pkg_qtsvg; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtsvg" >&5
$as_echo_n "checking for package qtsvg... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qtsvg-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qtsvg in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtsvg in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtsvg in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qtsvg";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qtsvg=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qtsvg_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qtsvg_deps="qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qtsvg"

  eval HAVE_PKG_QTSVG=\"\!define HAVE_PKG_QTSVG 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qtsvg qtsvg"
    if test ! -z "qtbase"; then :
  for _gpg4win_i in qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qtsvg"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qthttpserver was given.
if test "${enable_pkg_qthttpserver+set}" = set; then :
  enableval=$enable_pkg_qthttpserver; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qthttpserver" >&5
$as_echo_n "checking for package qthttpserver... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qthttpserver-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qthttpserver in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qthttpserver in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qthttpserver in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qthttpserver";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qthttpserver=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qthttpserver_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qthttpserver_deps="qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qthttpserver"

  eval HAVE_PKG_QTHTTPSERVER=\"\!define HAVE_PKG_QTHTTPSERVER 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qthttpserver qthttpserver"
    if test ! -z "qtbase"; then :
  for _gpg4win_i in qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qthttpserver"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-qtwebsockets was given.
if test "${enable_pkg_qtwebsockets+set}" = set; then :
  enableval=$enable_pkg_qtwebsockets; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtwebsockets" >&5
$as_echo_n "checking for package qtwebsockets... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='qtwebsockets-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for qtwebsockets in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtwebsockets in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtwebsockets in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources qtwebsockets";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_qtwebsockets=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_qtwebsockets_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_qtwebsockets_deps="qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs qtwebsockets"

  eval HAVE_PKG_QTWEBSOCKETS=\"\!define HAVE_PKG_QTWEBSOCKETS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps qtwebsockets qtwebsockets"
    if test ! -z "qtbase"; then :
  for _gpg4win_i in qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i qtwebsockets"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-tiff was given.
if test "${enable_pkg_tiff+set}" = set; then :
  enableval=$enable_pkg_tiff; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package tiff" >&5
$as_echo_n "checking for package tiff... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='tiff-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for tiff in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for tiff in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for tiff in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources tiff";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_tiff=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_tiff_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_tiff_deps=""


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs tiff"

  eval HAVE_PKG_TIFF=\"\!define HAVE_PKG_TIFF 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps tiff tiff"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i tiff"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-pcre2 was given.
if test "${enable_pkg_pcre2+set}" = set; then :
  enableval=$enable_pkg_pcre2; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pcre2" >&5
$as_echo_n "checking for package pcre2... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='pcre2-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for pcre2 in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pcre2 in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pcre2 in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources pcre2";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_pcre2=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_pcre2_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_pcre2_deps=""


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs pcre2"

  eval HAVE_PKG_PCRE2=\"\!define HAVE_PKG_PCRE2 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps pcre2 pcre2"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i pcre2"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-breeze was given.
if test "${enable_pkg_breeze+set}" = set; then :
  enableval=$enable_pkg_breeze; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package breeze" >&5
$as_echo_n "checking for package breeze... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='breeze-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for breeze in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for breeze in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for breeze in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources breeze";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_breeze=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_breeze_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_breeze_deps="qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem native-kconfig"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs breeze"

  eval HAVE_PKG_BREEZE=\"\!define HAVE_PKG_BREEZE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps breeze breeze"
    if test ! -z "qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem native-kconfig"; then :
  for _gpg4win_i in qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem native-kconfig; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i breeze"
          done
fi

fi

#   GPG4WIN_KDEPKG([snoretoast])


  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-openjpeg was given.
if test "${enable_pkg_openjpeg+set}" = set; then :
  enableval=$enable_pkg_openjpeg; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package openjpeg" >&5
$as_echo_n "checking for package openjpeg... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='openjpeg-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for openjpeg in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for openjpeg in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for openjpeg in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources openjpeg";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_openjpeg=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_openjpeg_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_openjpeg_deps="tiff jpeg"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs openjpeg"

  eval HAVE_PKG_OPENJPEG=\"\!define HAVE_PKG_OPENJPEG 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps openjpeg openjpeg"
    if test ! -z "tiff jpeg"; then :
  for _gpg4win_i in tiff jpeg; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i openjpeg"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-breeze-icons was given.
if test "${enable_pkg_breeze_icons+set}" = set; then :
  enableval=$enable_pkg_breeze_icons; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package breeze-icons" >&5
$as_echo_n "checking for package breeze-icons... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='breeze-icons-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for breeze-icons in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for breeze-icons in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for breeze-icons in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources breeze-icons";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_breeze_icons=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_breeze_icons_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_breeze_icons_deps="extra-cmake-modules qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs breeze-icons"

  eval HAVE_PKG_BREEZE_ICONS=\"\!define HAVE_PKG_BREEZE_ICONS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps breeze-icons breeze-icons"
    if test ! -z "extra-cmake-modules qtbase"; then :
  for _gpg4win_i in extra-cmake-modules qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i breeze-icons"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kleopatra was given.
if test "${enable_pkg_kleopatra+set}" = set; then :
  enableval=$enable_pkg_kleopatra; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kleopatra" >&5
$as_echo_n "checking for package kleopatra... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kleopatra-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kleopatra in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kleopatra in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kleopatra in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kleopatra";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kleopatra=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kleopatra_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kleopatra_deps="kstatusnotifieritem mimetreeparser kio gnupg-w32 breeze-icons kxmlgui libkleo kitemmodels qttranslations ktextwidgets native-kconfig"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kleopatra"

  eval HAVE_PKG_KLEOPATRA=\"\!define HAVE_PKG_KLEOPATRA 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kleopatra kleopatra"
    if test ! -z "kstatusnotifieritem mimetreeparser kio gnupg-w32 breeze-icons kxmlgui libkleo kitemmodels qttranslations ktextwidgets native-kconfig"; then :
  for _gpg4win_i in kstatusnotifieritem mimetreeparser kio gnupg-w32 breeze-icons kxmlgui libkleo kitemmodels qttranslations ktextwidgets native-kconfig; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kleopatra"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-extra-cmake-modules was given.
if test "${enable_pkg_extra_cmake_modules+set}" = set; then :
  enableval=$enable_pkg_extra_cmake_modules; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package extra-cmake-modules" >&5
$as_echo_n "checking for package extra-cmake-modules... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='extra-cmake-modules-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for extra-cmake-modules in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for extra-cmake-modules in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for extra-cmake-modules in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources extra-cmake-modules";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_extra_cmake_modules=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_extra_cmake_modules_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_extra_cmake_modules_deps=""


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs extra-cmake-modules"

  eval HAVE_PKG_EXTRA_CMAKE_MODULES=\"\!define HAVE_PKG_EXTRA_CMAKE_MODULES 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps extra-cmake-modules extra-cmake-modules"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i extra-cmake-modules"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kconfig was given.
if test "${enable_pkg_kconfig+set}" = set; then :
  enableval=$enable_pkg_kconfig; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kconfig" >&5
$as_echo_n "checking for package kconfig... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kconfig-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kconfig in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kconfig in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kconfig in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kconfig";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kconfig=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kconfig_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kconfig_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kconfig"

  eval HAVE_PKG_KCONFIG=\"\!define HAVE_PKG_KCONFIG 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kconfig kconfig"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kconfig"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-ki18n was given.
if test "${enable_pkg_ki18n+set}" = set; then :
  enableval=$enable_pkg_ki18n; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package ki18n" >&5
$as_echo_n "checking for package ki18n... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='ki18n-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for ki18n in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for ki18n in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for ki18n in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources ki18n";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_ki18n=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_ki18n_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_ki18n_deps="qtbase gettext native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs ki18n"

  eval HAVE_PKG_KI18N=\"\!define HAVE_PKG_KI18N 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps ki18n ki18n"
    if test ! -z "qtbase gettext native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase gettext native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i ki18n"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kwidgetsaddons was given.
if test "${enable_pkg_kwidgetsaddons+set}" = set; then :
  enableval=$enable_pkg_kwidgetsaddons; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kwidgetsaddons" >&5
$as_echo_n "checking for package kwidgetsaddons... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kwidgetsaddons-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kwidgetsaddons in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kwidgetsaddons in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kwidgetsaddons in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kwidgetsaddons";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kwidgetsaddons=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kwidgetsaddons_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kwidgetsaddons_deps="kconfig native-qttools qtbase"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kwidgetsaddons"

  eval HAVE_PKG_KWIDGETSADDONS=\"\!define HAVE_PKG_KWIDGETSADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kwidgetsaddons kwidgetsaddons"
    if test ! -z "kconfig native-qttools qtbase"; then :
  for _gpg4win_i in kconfig native-qttools qtbase; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kwidgetsaddons"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcompletion was given.
if test "${enable_pkg_kcompletion+set}" = set; then :
  enableval=$enable_pkg_kcompletion; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcompletion" >&5
$as_echo_n "checking for package kcompletion... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcompletion-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcompletion in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcompletion in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcompletion in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcompletion";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcompletion=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcompletion_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcompletion_deps="kwidgetsaddons"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcompletion"

  eval HAVE_PKG_KCOMPLETION=\"\!define HAVE_PKG_KCOMPLETION 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcompletion kcompletion"
    if test ! -z "kwidgetsaddons"; then :
  for _gpg4win_i in kwidgetsaddons; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcompletion"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kwindowsystem was given.
if test "${enable_pkg_kwindowsystem+set}" = set; then :
  enableval=$enable_pkg_kwindowsystem; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kwindowsystem" >&5
$as_echo_n "checking for package kwindowsystem... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kwindowsystem-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kwindowsystem in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kwindowsystem in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kwindowsystem in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kwindowsystem";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kwindowsystem=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kwindowsystem_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kwindowsystem_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kwindowsystem"

  eval HAVE_PKG_KWINDOWSYSTEM=\"\!define HAVE_PKG_KWINDOWSYSTEM 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kwindowsystem kwindowsystem"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kwindowsystem"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcoreaddons was given.
if test "${enable_pkg_kcoreaddons+set}" = set; then :
  enableval=$enable_pkg_kcoreaddons; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcoreaddons" >&5
$as_echo_n "checking for package kcoreaddons... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcoreaddons-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcoreaddons in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcoreaddons in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcoreaddons in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcoreaddons";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcoreaddons=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcoreaddons_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcoreaddons_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcoreaddons"

  eval HAVE_PKG_KCOREADDONS=\"\!define HAVE_PKG_KCOREADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcoreaddons kcoreaddons"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcoreaddons"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcodecs was given.
if test "${enable_pkg_kcodecs+set}" = set; then :
  enableval=$enable_pkg_kcodecs; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcodecs" >&5
$as_echo_n "checking for package kcodecs... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcodecs-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcodecs in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcodecs in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcodecs in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcodecs";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcodecs=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcodecs_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcodecs_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcodecs"

  eval HAVE_PKG_KCODECS=\"\!define HAVE_PKG_KCODECS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcodecs kcodecs"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcodecs"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kguiaddons was given.
if test "${enable_pkg_kguiaddons+set}" = set; then :
  enableval=$enable_pkg_kguiaddons; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kguiaddons" >&5
$as_echo_n "checking for package kguiaddons... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kguiaddons-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kguiaddons in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kguiaddons in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kguiaddons in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kguiaddons";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kguiaddons=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kguiaddons_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kguiaddons_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kguiaddons"

  eval HAVE_PKG_KGUIADDONS=\"\!define HAVE_PKG_KGUIADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kguiaddons kguiaddons"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kguiaddons"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kmime was given.
if test "${enable_pkg_kmime+set}" = set; then :
  enableval=$enable_pkg_kmime; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kmime" >&5
$as_echo_n "checking for package kmime... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kmime-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kmime in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kmime in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kmime in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kmime";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kmime=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kmime_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kmime_deps="kcodecs ki18n"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kmime"

  eval HAVE_PKG_KMIME=\"\!define HAVE_PKG_KMIME 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kmime kmime"
    if test ! -z "kcodecs ki18n"; then :
  for _gpg4win_i in kcodecs ki18n; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kmime"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kmbox was given.
if test "${enable_pkg_kmbox+set}" = set; then :
  enableval=$enable_pkg_kmbox; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kmbox" >&5
$as_echo_n "checking for package kmbox... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kmbox-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kmbox in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kmbox in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kmbox in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kmbox";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kmbox=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kmbox_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kmbox_deps="kmime"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kmbox"

  eval HAVE_PKG_KMBOX=\"\!define HAVE_PKG_KMBOX 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kmbox kmbox"
    if test ! -z "kmime"; then :
  for _gpg4win_i in kmime; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kmbox"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kconfigwidgets was given.
if test "${enable_pkg_kconfigwidgets+set}" = set; then :
  enableval=$enable_pkg_kconfigwidgets; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kconfigwidgets" >&5
$as_echo_n "checking for package kconfigwidgets... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kconfigwidgets-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kconfigwidgets in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kconfigwidgets in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kconfigwidgets in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kconfigwidgets";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kconfigwidgets=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kconfigwidgets_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kconfigwidgets_deps="kwidgetsaddons kguiaddons ki18n kcodecs kconfig kcolorscheme"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kconfigwidgets"

  eval HAVE_PKG_KCONFIGWIDGETS=\"\!define HAVE_PKG_KCONFIGWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kconfigwidgets kconfigwidgets"
    if test ! -z "kwidgetsaddons kguiaddons ki18n kcodecs kconfig kcolorscheme"; then :
  for _gpg4win_i in kwidgetsaddons kguiaddons ki18n kcodecs kconfig kcolorscheme; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kconfigwidgets"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kitemviews was given.
if test "${enable_pkg_kitemviews+set}" = set; then :
  enableval=$enable_pkg_kitemviews; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kitemviews" >&5
$as_echo_n "checking for package kitemviews... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kitemviews-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kitemviews in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kitemviews in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kitemviews in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kitemviews";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kitemviews=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kitemviews_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kitemviews_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kitemviews"

  eval HAVE_PKG_KITEMVIEWS=\"\!define HAVE_PKG_KITEMVIEWS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kitemviews kitemviews"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kitemviews"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kitemmodels was given.
if test "${enable_pkg_kitemmodels+set}" = set; then :
  enableval=$enable_pkg_kitemmodels; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kitemmodels" >&5
$as_echo_n "checking for package kitemmodels... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kitemmodels-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kitemmodels in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kitemmodels in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kitemmodels in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kitemmodels";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kitemmodels=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kitemmodels_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kitemmodels_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kitemmodels"

  eval HAVE_PKG_KITEMMODELS=\"\!define HAVE_PKG_KITEMMODELS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kitemmodels kitemmodels"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kitemmodels"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-karchive was given.
if test "${enable_pkg_karchive+set}" = set; then :
  enableval=$enable_pkg_karchive; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package karchive" >&5
$as_echo_n "checking for package karchive... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='karchive-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for karchive in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for karchive in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for karchive in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources karchive";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_karchive=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_karchive_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_karchive_deps="qtbase native-qttools extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs karchive"

  eval HAVE_PKG_KARCHIVE=\"\!define HAVE_PKG_KARCHIVE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps karchive karchive"
    if test ! -z "qtbase native-qttools extra-cmake-modules"; then :
  for _gpg4win_i in qtbase native-qttools extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i karchive"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcrash was given.
if test "${enable_pkg_kcrash+set}" = set; then :
  enableval=$enable_pkg_kcrash; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcrash" >&5
$as_echo_n "checking for package kcrash... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcrash-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcrash in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcrash in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcrash in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcrash";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcrash=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcrash_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcrash_deps="kwindowsystem kcoreaddons"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcrash"

  eval HAVE_PKG_KCRASH=\"\!define HAVE_PKG_KCRASH 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcrash kcrash"
    if test ! -z "kwindowsystem kcoreaddons"; then :
  for _gpg4win_i in kwindowsystem kcoreaddons; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcrash"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-solid was given.
if test "${enable_pkg_solid+set}" = set; then :
  enableval=$enable_pkg_solid; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package solid" >&5
$as_echo_n "checking for package solid... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='solid-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for solid in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for solid in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for solid in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources solid";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_solid=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_solid_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_solid_deps="native-qttools qtbase extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs solid"

  eval HAVE_PKG_SOLID=\"\!define HAVE_PKG_SOLID 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps solid solid"
    if test ! -z "native-qttools qtbase extra-cmake-modules"; then :
  for _gpg4win_i in native-qttools qtbase extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i solid"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kjobwidgets was given.
if test "${enable_pkg_kjobwidgets+set}" = set; then :
  enableval=$enable_pkg_kjobwidgets; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kjobwidgets" >&5
$as_echo_n "checking for package kjobwidgets... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kjobwidgets-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kjobwidgets in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kjobwidgets in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kjobwidgets in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kjobwidgets";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kjobwidgets=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kjobwidgets_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kjobwidgets_deps="kwidgetsaddons kcoreaddons qtbase extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kjobwidgets"

  eval HAVE_PKG_KJOBWIDGETS=\"\!define HAVE_PKG_KJOBWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kjobwidgets kjobwidgets"
    if test ! -z "kwidgetsaddons kcoreaddons qtbase extra-cmake-modules"; then :
  for _gpg4win_i in kwidgetsaddons kcoreaddons qtbase extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kjobwidgets"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kservice was given.
if test "${enable_pkg_kservice+set}" = set; then :
  enableval=$enable_pkg_kservice; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kservice" >&5
$as_echo_n "checking for package kservice... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kservice-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kservice in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kservice in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kservice in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kservice";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kservice=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kservice_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kservice_deps="kconfig kcoreaddons ki18n"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kservice"

  eval HAVE_PKG_KSERVICE=\"\!define HAVE_PKG_KSERVICE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kservice kservice"
    if test ! -z "kconfig kcoreaddons ki18n"; then :
  for _gpg4win_i in kconfig kcoreaddons ki18n; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kservice"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kbookmarks was given.
if test "${enable_pkg_kbookmarks+set}" = set; then :
  enableval=$enable_pkg_kbookmarks; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kbookmarks" >&5
$as_echo_n "checking for package kbookmarks... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kbookmarks-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kbookmarks in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kbookmarks in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kbookmarks in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kbookmarks";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kbookmarks=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kbookmarks_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kbookmarks_deps="kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kbookmarks"

  eval HAVE_PKG_KBOOKMARKS=\"\!define HAVE_PKG_KBOOKMARKS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kbookmarks kbookmarks"
    if test ! -z "kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs"; then :
  for _gpg4win_i in kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kbookmarks"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kio was given.
if test "${enable_pkg_kio+set}" = set; then :
  enableval=$enable_pkg_kio; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kio" >&5
$as_echo_n "checking for package kio... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kio-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kio in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kio in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kio in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kio";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kio=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kio_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kio_deps="kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kio"

  eval HAVE_PKG_KIO=\"\!define HAVE_PKG_KIO 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kio kio"
    if test ! -z "kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n"; then :
  for _gpg4win_i in kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kio"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kiconthemes was given.
if test "${enable_pkg_kiconthemes+set}" = set; then :
  enableval=$enable_pkg_kiconthemes; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kiconthemes" >&5
$as_echo_n "checking for package kiconthemes... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kiconthemes-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kiconthemes in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kiconthemes in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kiconthemes in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kiconthemes";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kiconthemes=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kiconthemes_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kiconthemes_deps="qtsvg kconfigwidgets karchive"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kiconthemes"

  eval HAVE_PKG_KICONTHEMES=\"\!define HAVE_PKG_KICONTHEMES 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kiconthemes kiconthemes"
    if test ! -z "qtsvg kconfigwidgets karchive"; then :
  for _gpg4win_i in qtsvg kconfigwidgets karchive; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kiconthemes"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kxmlgui was given.
if test "${enable_pkg_kxmlgui+set}" = set; then :
  enableval=$enable_pkg_kxmlgui; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kxmlgui" >&5
$as_echo_n "checking for package kxmlgui... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kxmlgui-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kxmlgui in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kxmlgui in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kxmlgui in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kxmlgui";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kxmlgui=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kxmlgui_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kxmlgui_deps="kiconthemes kconfigwidgets kitemviews ktextwidgets breeze"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kxmlgui"

  eval HAVE_PKG_KXMLGUI=\"\!define HAVE_PKG_KXMLGUI 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kxmlgui kxmlgui"
    if test ! -z "kiconthemes kconfigwidgets kitemviews ktextwidgets breeze"; then :
  for _gpg4win_i in kiconthemes kconfigwidgets kitemviews ktextwidgets breeze; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kxmlgui"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libkleo was given.
if test "${enable_pkg_libkleo+set}" = set; then :
  enableval=$enable_pkg_libkleo; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libkleo" >&5
$as_echo_n "checking for package libkleo... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libkleo-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libkleo in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libkleo in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libkleo in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libkleo";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libkleo=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libkleo_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libkleo_deps="kmime kconfigwidgets kwindowsystem kcompletion qgpgme"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libkleo"

  eval HAVE_PKG_LIBKLEO=\"\!define HAVE_PKG_LIBKLEO 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libkleo libkleo"
    if test ! -z "kmime kconfigwidgets kwindowsystem kcompletion qgpgme"; then :
  for _gpg4win_i in kmime kconfigwidgets kwindowsystem kcompletion qgpgme; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libkleo"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpg4win-tools was given.
if test "${enable_pkg_gpg4win_tools+set}" = set; then :
  enableval=$enable_pkg_gpg4win_tools; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpg4win-tools" >&5
$as_echo_n "checking for package gpg4win-tools... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpg4win-tools-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpg4win-tools in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpg4win-tools in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpg4win-tools in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpg4win-tools";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpg4win_tools=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpg4win_tools_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpg4win_tools_deps="libkleo qgpgme"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpg4win-tools"

  eval HAVE_PKG_GPG4WIN_TOOLS=\"\!define HAVE_PKG_GPG4WIN_TOOLS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpg4win-tools gpg4win-tools"
    if test ! -z "libkleo qgpgme"; then :
  for _gpg4win_i in libkleo qgpgme; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpg4win-tools"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-threadweaver was given.
if test "${enable_pkg_threadweaver+set}" = set; then :
  enableval=$enable_pkg_threadweaver; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package threadweaver" >&5
$as_echo_n "checking for package threadweaver... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='threadweaver-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for threadweaver in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for threadweaver in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for threadweaver in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources threadweaver";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_threadweaver=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_threadweaver_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_threadweaver_deps="qtbase extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs threadweaver"

  eval HAVE_PKG_THREADWEAVER=\"\!define HAVE_PKG_THREADWEAVER 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps threadweaver threadweaver"
    if test ! -z "qtbase extra-cmake-modules"; then :
  for _gpg4win_i in qtbase extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i threadweaver"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcolorscheme was given.
if test "${enable_pkg_kcolorscheme+set}" = set; then :
  enableval=$enable_pkg_kcolorscheme; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcolorscheme" >&5
$as_echo_n "checking for package kcolorscheme... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcolorscheme-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcolorscheme in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcolorscheme in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcolorscheme in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcolorscheme";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcolorscheme=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcolorscheme_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcolorscheme_deps="kconfig kguiaddons ki18n"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcolorscheme"

  eval HAVE_PKG_KCOLORSCHEME=\"\!define HAVE_PKG_KCOLORSCHEME 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcolorscheme kcolorscheme"
    if test ! -z "kconfig kguiaddons ki18n"; then :
  for _gpg4win_i in kconfig kguiaddons ki18n; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcolorscheme"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-freetype was given.
if test "${enable_pkg_freetype+set}" = set; then :
  enableval=$enable_pkg_freetype; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package freetype" >&5
$as_echo_n "checking for package freetype... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='freetype-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for freetype in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for freetype in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for freetype in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources freetype";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_freetype=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_freetype_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_freetype_deps="zlib bzip2"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs freetype"

  eval HAVE_PKG_FREETYPE=\"\!define HAVE_PKG_FREETYPE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps freetype freetype"
    if test ! -z "zlib bzip2"; then :
  for _gpg4win_i in zlib bzip2; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i freetype"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-sonnet was given.
if test "${enable_pkg_sonnet+set}" = set; then :
  enableval=$enable_pkg_sonnet; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package sonnet" >&5
$as_echo_n "checking for package sonnet... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='sonnet-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for sonnet in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for sonnet in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for sonnet in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources sonnet";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_sonnet=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_sonnet_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_sonnet_deps="qtbase native-qttools"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs sonnet"

  eval HAVE_PKG_SONNET=\"\!define HAVE_PKG_SONNET 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps sonnet sonnet"
    if test ! -z "qtbase native-qttools"; then :
  for _gpg4win_i in qtbase native-qttools; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i sonnet"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-ktextwidgets was given.
if test "${enable_pkg_ktextwidgets+set}" = set; then :
  enableval=$enable_pkg_ktextwidgets; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package ktextwidgets" >&5
$as_echo_n "checking for package ktextwidgets... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='ktextwidgets-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for ktextwidgets in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for ktextwidgets in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for ktextwidgets in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources ktextwidgets";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_ktextwidgets=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_ktextwidgets_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_ktextwidgets_deps="sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs ktextwidgets"

  eval HAVE_PKG_KTEXTWIDGETS=\"\!define HAVE_PKG_KTEXTWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps ktextwidgets ktextwidgets"
    if test ! -z "sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons"; then :
  for _gpg4win_i in sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i ktextwidgets"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-poppler was given.
if test "${enable_pkg_poppler+set}" = set; then :
  enableval=$enable_pkg_poppler; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package poppler" >&5
$as_echo_n "checking for package poppler... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='poppler-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for poppler in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for poppler in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for poppler in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources poppler";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_poppler=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_poppler_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_poppler_deps="libpng openjpeg tiff gpgmepp kio qtbase freetype"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs poppler"

  eval HAVE_PKG_POPPLER=\"\!define HAVE_PKG_POPPLER 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps poppler poppler"
    if test ! -z "libpng openjpeg tiff gpgmepp kio qtbase freetype"; then :
  for _gpg4win_i in libpng openjpeg tiff gpgmepp kio qtbase freetype; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i poppler"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kparts was given.
if test "${enable_pkg_kparts+set}" = set; then :
  enableval=$enable_pkg_kparts; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kparts" >&5
$as_echo_n "checking for package kparts... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kparts-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kparts in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kparts in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kparts in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kparts";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kparts=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kparts_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kparts_deps="kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kparts"

  eval HAVE_PKG_KPARTS=\"\!define HAVE_PKG_KPARTS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kparts kparts"
    if test ! -z "kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets"; then :
  for _gpg4win_i in kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kparts"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-okular was given.
if test "${enable_pkg_okular+set}" = set; then :
  enableval=$enable_pkg_okular; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package okular" >&5
$as_echo_n "checking for package okular... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='okular-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for okular in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for okular in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for okular in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources okular";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_okular=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_okular_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_okular_deps="kparts gpgmepp kio poppler threadweaver qtsvg native-kconfig"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs okular"

  eval HAVE_PKG_OKULAR=\"\!define HAVE_PKG_OKULAR 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps okular okular"
    if test ! -z "kparts gpgmepp kio poppler threadweaver qtsvg native-kconfig"; then :
  for _gpg4win_i in kparts gpgmepp kio poppler threadweaver qtsvg native-kconfig; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i okular"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-libical was given.
if test "${enable_pkg_libical+set}" = set; then :
  enableval=$enable_pkg_libical; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libical" >&5
$as_echo_n "checking for package libical... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='libical-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for libical in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libical in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libical in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources libical";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_libical=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_libical_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_libical_deps=""


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs libical"

  eval HAVE_PKG_LIBICAL=\"\!define HAVE_PKG_LIBICAL 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps libical libical"
    if test ! -z ""; then :
  for _gpg4win_i in ; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i libical"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcalendarcore was given.
if test "${enable_pkg_kcalendarcore+set}" = set; then :
  enableval=$enable_pkg_kcalendarcore; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcalendarcore" >&5
$as_echo_n "checking for package kcalendarcore... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcalendarcore-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcalendarcore in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcalendarcore in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcalendarcore in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcalendarcore";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcalendarcore=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcalendarcore_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcalendarcore_deps="qtbase libical extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcalendarcore"

  eval HAVE_PKG_KCALENDARCORE=\"\!define HAVE_PKG_KCALENDARCORE 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcalendarcore kcalendarcore"
    if test ! -z "qtbase libical extra-cmake-modules"; then :
  for _gpg4win_i in qtbase libical extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcalendarcore"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-mimetreeparser was given.
if test "${enable_pkg_mimetreeparser+set}" = set; then :
  enableval=$enable_pkg_mimetreeparser; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package mimetreeparser" >&5
$as_echo_n "checking for package mimetreeparser... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='mimetreeparser-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for mimetreeparser in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for mimetreeparser in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for mimetreeparser in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources mimetreeparser";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_mimetreeparser=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_mimetreeparser_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_mimetreeparser_deps="libkleo kwidgetsaddons ki18n kmbox kmime kcodecs kcalendarcore"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs mimetreeparser"

  eval HAVE_PKG_MIMETREEPARSER=\"\!define HAVE_PKG_MIMETREEPARSER 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps mimetreeparser mimetreeparser"
    if test ! -z "libkleo kwidgetsaddons ki18n kmbox kmime kcodecs kcalendarcore"; then :
  for _gpg4win_i in libkleo kwidgetsaddons ki18n kmbox kmime kcodecs kcalendarcore; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i mimetreeparser"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-prison was given.
if test "${enable_pkg_prison+set}" = set; then :
  enableval=$enable_pkg_prison; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package prison" >&5
$as_echo_n "checking for package prison... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='prison-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for prison in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for prison in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for prison in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources prison";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_prison=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_prison_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_prison_deps="qtbase extra-cmake-modules qrencode"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs prison"

  eval HAVE_PKG_PRISON=\"\!define HAVE_PKG_PRISON 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps prison prison"
    if test ! -z "qtbase extra-cmake-modules qrencode"; then :
  for _gpg4win_i in qtbase extra-cmake-modules qrencode; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i prison"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kstatusnotifieritem was given.
if test "${enable_pkg_kstatusnotifieritem+set}" = set; then :
  enableval=$enable_pkg_kstatusnotifieritem; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kstatusnotifieritem" >&5
$as_echo_n "checking for package kstatusnotifieritem... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kstatusnotifieritem-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kstatusnotifieritem in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kstatusnotifieritem in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kstatusnotifieritem in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kstatusnotifieritem";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kstatusnotifieritem=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kstatusnotifieritem_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kstatusnotifieritem_deps="kwindowsystem qtbase extra-cmake-modules"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kstatusnotifieritem"

  eval HAVE_PKG_KSTATUSNOTIFIERITEM=\"\!define HAVE_PKG_KSTATUSNOTIFIERITEM 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kstatusnotifieritem kstatusnotifieritem"
    if test ! -z "kwindowsystem qtbase extra-cmake-modules"; then :
  for _gpg4win_i in kwindowsystem qtbase extra-cmake-modules; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kstatusnotifieritem"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgpass was given.
if test "${enable_pkg_gpgpass+set}" = set; then :
  enableval=$enable_pkg_gpgpass; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgpass" >&5
$as_echo_n "checking for package gpgpass... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgpass-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgpass in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgpass in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgpass in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgpass";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgpass=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgpass_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgpass_deps="kio prison kconfigwidgets kiconthemes ki18n qgpgme native-kconfig"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgpass"

  eval HAVE_PKG_GPGPASS=\"\!define HAVE_PKG_GPGPASS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgpass gpgpass"
    if test ! -z "kio prison kconfigwidgets kiconthemes ki18n qgpgme native-kconfig"; then :
  for _gpg4win_i in kio prison kconfigwidgets kiconthemes ki18n qgpgme native-kconfig; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgpass"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-kcontacts was given.
if test "${enable_pkg_kcontacts+set}" = set; then :
  enableval=$enable_pkg_kcontacts; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcontacts" >&5
$as_echo_n "checking for package kcontacts... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='kcontacts-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for kcontacts in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcontacts in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcontacts in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources kcontacts";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_kcontacts=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_kcontacts_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_kcontacts_deps="kcoreaddons qtbase ki18n kconfig kcodecs"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs kcontacts"

  eval HAVE_PKG_KCONTACTS=\"\!define HAVE_PKG_KCONTACTS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps kcontacts kcontacts"
    if test ! -z "kcoreaddons qtbase ki18n kconfig kcodecs"; then :
  for _gpg4win_i in kcoreaddons qtbase ki18n kconfig kcodecs; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i kcontacts"
          done
fi

fi



  _gpg4win_pkg=maybe
  # Check whether --enable-pkg-gpgoljs was given.
if test "${enable_pkg_gpgoljs+set}" = set; then :
  enableval=$enable_pkg_gpgoljs; _gpg4win_pkg=$enableval
fi

  _gpg4win_kdepkg=no
  _gpg4win_version=
  if test "$_gpg4win_pkg" != no; then :




  gpg4win_val=
  gpg4win_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgoljs" >&5
$as_echo_n "checking for package gpgoljs... " >&6; }
  _gpg4win_critical=no
  _gpg4win_file=
  _gpg4win_dir=$_gpg4win_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_gpg4win_dir != xmaybe; then :
  _gpg4win_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_gpg4win_auto_detection = yes -o $_gpg4win_critical = yes; then :
  if test -z "$_gpg4win_dir" -o "$_gpg4win_dir" = yes -o "$_gpg4win_dir" = maybe; then :
  _gpg4win_dir=$gpg4win_packages
fi

    # Install pattern.
    if test -z ""; then :
  _gpg4win_pat='gpgoljs-\([0-9].*\)'
else
  _gpg4win_pat=""
fi

    # Frob pattern.  Regex party!
    _gpg4win_glob=`echo "$_gpg4win_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _gpg4win_glob=`echo "$_gpg4win_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _gpg4win_format=both
    if test ! -z ""; then :
  _gpg4win_format=""
fi

    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.xz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.bz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz2`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tbz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tar.gz`
fi
    if test $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.tgz`
fi
    if test $_gpg4win_format != tar; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.zip`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.exe`
fi
    if test $_gpg4win_format != tar -a $_gpg4win_format != zip; then :
  _gpg4win_file="$_gpg4win_file "`echo ${_gpg4win_dir}/${_gpg4win_glob}.wixlib`
fi
    shopt -u nullglob
fi

  # remove leading and trailing whitespace
  _gpg4win_file=`echo $_gpg4win_file`

  if test -z "$_gpg4win_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_gpg4win_file | head -c 1` != /; then :
  _gpg4win_file=`pwd`/$_gpg4win_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_gpg4win_file" >&5
$as_echo "$_gpg4win_file" >&6; }
fi
  if test -z "$_gpg4win_file" -a $_gpg4win_critical = yes; then :
  as_fn_error $? "could not find sources for gpgoljs in $_gpg4win_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _gpg4win_found=
  for _gpg4win_f in $_gpg4win_file; do
      if test "$_gpg4win_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgoljs in $_gpg4win_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgoljs in $_gpg4win_dir" >&2;}
             gpg4win_dup_sources="$gpg4win_dup_sources gpgoljs";
             gpg4win_rm_candidates="$gpg4win_rm_candidates $_gpg4win_file"
fi
      _gpg4win_found=yes
  done

  _gpg4win_suffix_pat='\.\(tar.xz\|tar.bz2\|tbz2\|tbz\|tar.gz\|tgz\|zip\|exe\|wixlib\)'
  if test ! -z "$_gpg4win_file"; then :
  gpg4win_val="$_gpg4win_file"
         gpg4win_version=`echo "$gpg4win_val" | sed -e "s,^.*/${_gpg4win_pat}${_gpg4win_suffix_pat}$,\1,"`
         _gpg4win_kdepkg=$gpg4win_val
        _gpg4win_version=$gpg4win_version
fi

fi

  # gpg4win_pkg_PKGNAME=FILENAME_OF_SOURCE
  gpg4win_pkg_gpgoljs=$_gpg4win_kdepkg


  # gpg4win_pkg_PKGNAME_version=VERSION
  gpg4win_pkg_gpgoljs_version=$_gpg4win_version


  # gpg4win_pkg_PKGNAME_deps=DEPS
  gpg4win_pkg_gpgoljs_deps="qtwebsockets kcontacts qthttpserver mimetreeparser libkleo sonnet kcompletion ki18n kwidgetsaddons kio"


  if test "$_gpg4win_kdepkg" != no; then :
  _gpg4win_pkgs="$_gpg4win_pkgs gpgoljs"

  eval HAVE_PKG_GPGOLJS=\"\!define HAVE_PKG_GPGOLJS 1\"


    # Record dependencies.  Also enter every package as node.
    _gpg4win_deps="$_gpg4win_deps gpgoljs gpgoljs"
    if test ! -z "qtwebsockets kcontacts qthttpserver mimetreeparser libkleo sonnet kcompletion ki18n kwidgetsaddons kio"; then :
  for _gpg4win_i in qtwebsockets kcontacts qthttpserver mimetreeparser libkleo sonnet kcompletion ki18n kwidgetsaddons kio; do
            _gpg4win_deps="$_gpg4win_deps $_gpg4win_i gpgoljs"
          done
fi

fi



  { $as_echo "$as_me:${as_lineno-$LINENO}: checking build list" >&5
$as_echo_n "checking build list... " >&6; }
  gpg4win_build_list=`echo $_gpg4win_deps | tsort`
  # Remove newlines.
  gpg4win_build_list=`echo $gpg4win_build_list`
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gpg4win_build_list" >&5
$as_echo "$gpg4win_build_list" >&6; }

  # Get list of packages for NSIS.
  gpg4win_nsis_list=`echo $_gpg4win_deps | tsort | grep -v ^native-`
  gpg4win_nsis_list=`echo $gpg4win_nsis_list`


  # Check each dependency.
  _gpg4win_not_found=
  _gpg4win_d=
  _gpg4win_p=
  for _gpg4win_p in $_gpg4win_deps; do
    if test -z $_gpg4win_d; then :
  _gpg4win_d=$_gpg4win_p
else

            _gpg4win_found=
            for _gpg4win_i in $_gpg4win_pkgs; do
              if test $_gpg4win_d = $_gpg4win_i; then :
  _gpg4win_found=yes
                    break
fi
            done
            if test -z $_gpg4win_found; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: could not find package $_gpg4win_d required by package $_gpg4win_p" >&5
$as_echo "$as_me: WARNING: could not find package $_gpg4win_d required by package $_gpg4win_p" >&2;}
                  _gpg4win_not_found=yes
fi
            _gpg4win_d=

fi
  done
  if test ! -z "$_gpg4win_not_found"; then :
  as_fn_error $? "could not find some required packages" "$LINENO" 5
fi




  { $as_echo "$as_me:${as_lineno-$LINENO}: checking additional host build list" >&5
$as_echo_n "checking additional host build list... " >&6; }

  gpg4win_build_ex_list=`echo $_gpg4win_ex_deps | tsort`
  # Remove newlines.
  gpg4win_build_ex_list=`echo $gpg4win_build_ex_list`
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gpg4win_build_ex_list" >&5
$as_echo "$gpg4win_build_ex_list" >&6; }


  # Check each dependency.
  _gpg4win_not_found=
  _gpg4win_d=
  _gpg4win_p=
  for _gpg4win_p in $_gpg4win_ex_deps; do
    if test -z $_gpg4win_d; then :
  _gpg4win_d=$_gpg4win_p
else

            _gpg4win_found=
            for _gpg4win_i in $_gpg4win_pkgs; do
              if test $_gpg4win_d = $_gpg4win_i; then :
  _gpg4win_found=yes
                    break
fi
            done
            if test -z $_gpg4win_found; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: could not find ex variant of package $_gpg4win_d required by package $_gpg4win_p" >&5
$as_echo "$as_me: WARNING: could not find ex variant of package $_gpg4win_d required by package $_gpg4win_p" >&2;}
                  _gpg4win_not_found=yes
fi
            _gpg4win_d=

fi
  done
  if test ! -z "$_gpg4win_not_found"; then :
  as_fn_error $? "could not find some required packages" "$LINENO" 5
fi




  _gpg4win_debug=no
  # Check whether --enable-debug was given.
if test "${enable_debug+set}" = set; then :
  enableval=$enable_debug; _gpg4win_debug=$enableval
fi


  if test "${_gpg4win_debug}" != no; then :

  eval GPG4WIN_DEBUG=\"\!define GPG4WIN_DEBUG 1\"


fi

fi

# Packages for the AppImage
if test "$build_appimage" = yes ; then
    appimage_dup_sources=""


  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for packages directory" >&5
$as_echo_n "checking for packages directory... " >&6; }
  _appimage_packages_default=/src/packages

# Check whether --with-packages was given.
if test "${with_packages+set}" = set; then :
  withval=$with_packages; appimage_packages=$withval
fi

  if test -z $appimage_packages; then :
  appimage_packages=$_appimage_packages_default
fi
  if test `echo $appimage_packages | head -c 1` != /; then :
  appimage_packages=`pwd`/$appimage_packages
fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $appimage_packages" >&5
$as_echo "$appimage_packages" >&6; }

  # Set auto-detection.  FIXME: This should accept a comma-separated
  # list of packages that will be autodetected.
  _appimage_auto_detection=yes
  # Check whether --enable-packages was given.
if test "${enable_packages+set}" = set; then :
  enableval=$enable_packages; _appimage_auto_detection=$enableval
fi



  # We call this here so its options appear before the per-package options.



  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Bash" >&5
$as_echo_n "checking for Bash... " >&6; }
  _bash=$BASH_VERSION
  if test -z "$_bash"; then
    _bash=no
  fi
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_bash" >&5
$as_echo "$_bash" >&6; }
  if test $_bash = no; then
    as_fn_error $? "\"this configure script requires Bash\"" "$LINENO" 5
  fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-freetype was given.
if test "${enable_pkg_freetype+set}" = set; then :
  enableval=$enable_pkg_freetype; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package freetype" >&5
$as_echo_n "checking for package freetype... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='freetype-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for freetype in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for freetype in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for freetype in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources freetype";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_freetype=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_freetype_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_freetype_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs freetype"

  eval HAVE_PKG_FREETYPE=\"\!define HAVE_PKG_FREETYPE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps freetype freetype"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i freetype"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-sqlite was given.
if test "${enable_pkg_sqlite+set}" = set; then :
  enableval=$enable_pkg_sqlite; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package sqlite" >&5
$as_echo_n "checking for package sqlite... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='sqlite-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for sqlite in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for sqlite in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for sqlite in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources sqlite";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_sqlite=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_sqlite_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_sqlite_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs sqlite"

  eval HAVE_PKG_SQLITE=\"\!define HAVE_PKG_SQLITE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps sqlite sqlite"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i sqlite"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-jpeg was given.
if test "${enable_pkg_jpeg+set}" = set; then :
  enableval=$enable_pkg_jpeg; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package jpeg" >&5
$as_echo_n "checking for package jpeg... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='jpeg-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for jpeg in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for jpeg in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for jpeg in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources jpeg";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_jpeg=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_jpeg_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_jpeg_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs jpeg"

  eval HAVE_PKG_JPEG=\"\!define HAVE_PKG_JPEG 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps jpeg jpeg"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i jpeg"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qrencode was given.
if test "${enable_pkg_qrencode+set}" = set; then :
  enableval=$enable_pkg_qrencode; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qrencode" >&5
$as_echo_n "checking for package qrencode... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qrencode-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qrencode in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qrencode in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qrencode in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qrencode";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qrencode=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qrencode_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qrencode_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qrencode"

  eval HAVE_PKG_QRENCODE=\"\!define HAVE_PKG_QRENCODE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qrencode qrencode"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i qrencode"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-xcb-util-cursor was given.
if test "${enable_pkg_xcb_util_cursor+set}" = set; then :
  enableval=$enable_pkg_xcb_util_cursor; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package xcb-util-cursor" >&5
$as_echo_n "checking for package xcb-util-cursor... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='xcb-util-cursor-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for xcb-util-cursor in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for xcb-util-cursor in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for xcb-util-cursor in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources xcb-util-cursor";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_xcb_util_cursor=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_xcb_util_cursor_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_xcb_util_cursor_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs xcb-util-cursor"

  eval HAVE_PKG_XCB_UTIL_CURSOR=\"\!define HAVE_PKG_XCB_UTIL_CURSOR 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps xcb-util-cursor xcb-util-cursor"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i xcb-util-cursor"
          done
fi

fi




  _appimage_pkg=maybe
  # Check whether --enable-pkg-libgpg-error was given.
if test "${enable_pkg_libgpg_error+set}" = set; then :
  enableval=$enable_pkg_libgpg_error; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libgpg-error" >&5
$as_echo_n "checking for package libgpg-error... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libgpg-error-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libgpg-error in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libgpg-error in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libgpg-error in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libgpg-error";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libgpg_error=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libgpg_error_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libgpg_error_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libgpg-error"

  eval HAVE_PKG_LIBGPG_ERROR=\"\!define HAVE_PKG_LIBGPG_ERROR 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libgpg-error libgpg-error"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i libgpg-error"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-libassuan was given.
if test "${enable_pkg_libassuan+set}" = set; then :
  enableval=$enable_pkg_libassuan; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libassuan" >&5
$as_echo_n "checking for package libassuan... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libassuan-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libassuan in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libassuan in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libassuan in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libassuan";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libassuan=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libassuan_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libassuan_deps="libgpg-error"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libassuan"

  eval HAVE_PKG_LIBASSUAN=\"\!define HAVE_PKG_LIBASSUAN 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libassuan libassuan"
    if test ! -z "libgpg-error"; then :
  for _appimage_i in libgpg-error; do
            _appimage_deps="$_appimage_deps $_appimage_i libassuan"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-npth was given.
if test "${enable_pkg_npth+set}" = set; then :
  enableval=$enable_pkg_npth; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package npth" >&5
$as_echo_n "checking for package npth... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='npth-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for npth in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for npth in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for npth in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources npth";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_npth=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_npth_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_npth_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs npth"

  eval HAVE_PKG_NPTH=\"\!define HAVE_PKG_NPTH 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps npth npth"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i npth"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-libgcrypt was given.
if test "${enable_pkg_libgcrypt+set}" = set; then :
  enableval=$enable_pkg_libgcrypt; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libgcrypt" >&5
$as_echo_n "checking for package libgcrypt... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libgcrypt-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libgcrypt in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libgcrypt in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libgcrypt in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libgcrypt";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libgcrypt=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libgcrypt_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libgcrypt_deps="libgpg-error"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libgcrypt"

  eval HAVE_PKG_LIBGCRYPT=\"\!define HAVE_PKG_LIBGCRYPT 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libgcrypt libgcrypt"
    if test ! -z "libgpg-error"; then :
  for _appimage_i in libgpg-error; do
            _appimage_deps="$_appimage_deps $_appimage_i libgcrypt"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-libksba was given.
if test "${enable_pkg_libksba+set}" = set; then :
  enableval=$enable_pkg_libksba; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libksba" >&5
$as_echo_n "checking for package libksba... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libksba-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libksba in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libksba in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libksba in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libksba";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libksba=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libksba_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libksba_deps="libgpg-error"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libksba"

  eval HAVE_PKG_LIBKSBA=\"\!define HAVE_PKG_LIBKSBA 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libksba libksba"
    if test ! -z "libgpg-error"; then :
  for _appimage_i in libgpg-error; do
            _appimage_deps="$_appimage_deps $_appimage_i libksba"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-ntbtls was given.
if test "${enable_pkg_ntbtls+set}" = set; then :
  enableval=$enable_pkg_ntbtls; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package ntbtls" >&5
$as_echo_n "checking for package ntbtls... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='ntbtls-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for ntbtls in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for ntbtls in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for ntbtls in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources ntbtls";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_ntbtls=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_ntbtls_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_ntbtls_deps="libgcrypt libksba"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs ntbtls"

  eval HAVE_PKG_NTBTLS=\"\!define HAVE_PKG_NTBTLS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps ntbtls ntbtls"
    if test ! -z "libgcrypt libksba"; then :
  for _appimage_i in libgcrypt libksba; do
            _appimage_deps="$_appimage_deps $_appimage_i ntbtls"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-gnupg was given.
if test "${enable_pkg_gnupg+set}" = set; then :
  enableval=$enable_pkg_gnupg; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gnupg" >&5
$as_echo_n "checking for package gnupg... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='gnupg-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for gnupg in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gnupg in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gnupg in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources gnupg";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_gnupg=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_gnupg_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_gnupg_deps="libgpg-error libassuan npth libgcrypt libksba sqlite ntbtls"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs gnupg"

  eval HAVE_PKG_GNUPG=\"\!define HAVE_PKG_GNUPG 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps gnupg gnupg"
    if test ! -z "libgpg-error libassuan npth libgcrypt libksba sqlite ntbtls"; then :
  for _appimage_i in libgpg-error libassuan npth libgcrypt libksba sqlite ntbtls; do
            _appimage_deps="$_appimage_deps $_appimage_i gnupg"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-pinentry was given.
if test "${enable_pkg_pinentry+set}" = set; then :
  enableval=$enable_pkg_pinentry; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pinentry" >&5
$as_echo_n "checking for package pinentry... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='pinentry-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for pinentry in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pinentry in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pinentry in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources pinentry";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_pinentry=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_pinentry_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_pinentry_deps="qtbase"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs pinentry"

  eval HAVE_PKG_PINENTRY=\"\!define HAVE_PKG_PINENTRY 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps pinentry pinentry"
    if test ! -z "qtbase"; then :
  for _appimage_i in qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i pinentry"
          done
fi

fi




  _appimage_pkg=maybe
  # Check whether --enable-pkg-gpgme was given.
if test "${enable_pkg_gpgme+set}" = set; then :
  enableval=$enable_pkg_gpgme; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgme" >&5
$as_echo_n "checking for package gpgme... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='gpgme-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for gpgme in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgme in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgme in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources gpgme";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_gpgme=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_gpgme_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_gpgme_deps="libgpg-error libassuan"


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs gpgme"

  eval HAVE_PKG_GPGME=\"\!define HAVE_PKG_GPGME 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps gpgme gpgme"
    if test ! -z "libgpg-error libassuan"; then :
  for _appimage_i in libgpg-error libassuan; do
            _appimage_deps="$_appimage_deps $_appimage_i gpgme"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-gpgmepp was given.
if test "${enable_pkg_gpgmepp+set}" = set; then :
  enableval=$enable_pkg_gpgmepp; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgmepp" >&5
$as_echo_n "checking for package gpgmepp... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='gpgmepp-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for gpgmepp in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgmepp in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgmepp in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources gpgmepp";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_gpgmepp=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_gpgmepp_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_gpgmepp_deps="gpgme"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs gpgmepp"

  eval HAVE_PKG_GPGMEPP=\"\!define HAVE_PKG_GPGMEPP 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps gpgmepp gpgmepp"
    if test ! -z "gpgme"; then :
  for _appimage_i in gpgme; do
            _appimage_deps="$_appimage_deps $_appimage_i gpgmepp"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qgpgme was given.
if test "${enable_pkg_qgpgme+set}" = set; then :
  enableval=$enable_pkg_qgpgme; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qgpgme" >&5
$as_echo_n "checking for package qgpgme... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qgpgme-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qgpgme in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qgpgme in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qgpgme in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qgpgme";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qgpgme=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qgpgme_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qgpgme_deps="gpgmepp qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qgpgme"

  eval HAVE_PKG_QGPGME=\"\!define HAVE_PKG_QGPGME 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qgpgme qgpgme"
    if test ! -z "gpgmepp qtbase"; then :
  for _appimage_i in gpgmepp qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i qgpgme"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-paperkey was given.
if test "${enable_pkg_paperkey+set}" = set; then :
  enableval=$enable_pkg_paperkey; _appimage_pkg=$enableval
fi

  _appimage_spkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package paperkey" >&5
$as_echo_n "checking for package paperkey... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='paperkey-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for paperkey in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for paperkey in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for paperkey in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources paperkey";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_spkg=$appimage_val
	 _appimage_version=$appimage_version
fi

fi

  # At this point, _appimage_spkg is no, or the actual package source file.

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_paperkey=$_appimage_spkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_paperkey_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_paperkey_deps=""


  if test "$_appimage_spkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs paperkey"

  eval HAVE_PKG_PAPERKEY=\"\!define HAVE_PKG_PAPERKEY 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps paperkey paperkey"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i paperkey"
          done
fi

fi


    # Qt related stuff.
    # (dependency on gnupg is only to make sure gnupg is build first so
    #  that we don't need to wait for the long running Qt builds)


  _appimage_pkg=maybe
  # Check whether --enable-pkg-zstd was given.
if test "${enable_pkg_zstd+set}" = set; then :
  enableval=$enable_pkg_zstd; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package zstd" >&5
$as_echo_n "checking for package zstd... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='zstd-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for zstd in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for zstd in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for zstd in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources zstd";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_zstd=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_zstd_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_zstd_deps=""


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs zstd"

  eval HAVE_PKG_ZSTD=\"\!define HAVE_PKG_ZSTD 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps zstd zstd"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i zstd"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-pcre2 was given.
if test "${enable_pkg_pcre2+set}" = set; then :
  enableval=$enable_pkg_pcre2; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package pcre2" >&5
$as_echo_n "checking for package pcre2... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='pcre2-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for pcre2 in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for pcre2 in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for pcre2 in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources pcre2";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_pcre2=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_pcre2_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_pcre2_deps=""


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs pcre2"

  eval HAVE_PKG_PCRE2=\"\!define HAVE_PKG_PCRE2 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps pcre2 pcre2"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i pcre2"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qtbase was given.
if test "${enable_pkg_qtbase+set}" = set; then :
  enableval=$enable_pkg_qtbase; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtbase" >&5
$as_echo_n "checking for package qtbase... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qtbase-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qtbase in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtbase in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtbase in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qtbase";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qtbase=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qtbase_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qtbase_deps="jpeg zstd freetype pcre2 gnupg xcb-util-cursor"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qtbase"

  eval HAVE_PKG_QTBASE=\"\!define HAVE_PKG_QTBASE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qtbase qtbase"
    if test ! -z "jpeg zstd freetype pcre2 gnupg xcb-util-cursor"; then :
  for _appimage_i in jpeg zstd freetype pcre2 gnupg xcb-util-cursor; do
            _appimage_deps="$_appimage_deps $_appimage_i qtbase"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qttools was given.
if test "${enable_pkg_qttools+set}" = set; then :
  enableval=$enable_pkg_qttools; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qttools" >&5
$as_echo_n "checking for package qttools... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qttools-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qttools in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qttools in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qttools in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qttools";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qttools=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qttools_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qttools_deps="qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qttools"

  eval HAVE_PKG_QTTOOLS=\"\!define HAVE_PKG_QTTOOLS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qttools qttools"
    if test ! -z "qtbase"; then :
  for _appimage_i in qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i qttools"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qttranslations was given.
if test "${enable_pkg_qttranslations+set}" = set; then :
  enableval=$enable_pkg_qttranslations; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qttranslations" >&5
$as_echo_n "checking for package qttranslations... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qttranslations-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qttranslations in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qttranslations in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qttranslations in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qttranslations";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qttranslations=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qttranslations_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qttranslations_deps="qtsvg qttools"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qttranslations"

  eval HAVE_PKG_QTTRANSLATIONS=\"\!define HAVE_PKG_QTTRANSLATIONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qttranslations qttranslations"
    if test ! -z "qtsvg qttools"; then :
  for _appimage_i in qtsvg qttools; do
            _appimage_deps="$_appimage_deps $_appimage_i qttranslations"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qtsvg was given.
if test "${enable_pkg_qtsvg+set}" = set; then :
  enableval=$enable_pkg_qtsvg; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtsvg" >&5
$as_echo_n "checking for package qtsvg... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qtsvg-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qtsvg in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtsvg in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtsvg in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qtsvg";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qtsvg=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qtsvg_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qtsvg_deps="qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qtsvg"

  eval HAVE_PKG_QTSVG=\"\!define HAVE_PKG_QTSVG 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qtsvg qtsvg"
    if test ! -z "qtbase"; then :
  for _appimage_i in qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i qtsvg"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-qtwayland was given.
if test "${enable_pkg_qtwayland+set}" = set; then :
  enableval=$enable_pkg_qtwayland; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package qtwayland" >&5
$as_echo_n "checking for package qtwayland... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='qtwayland-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for qtwayland in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for qtwayland in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for qtwayland in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources qtwayland";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_qtwayland=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_qtwayland_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_qtwayland_deps="qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs qtwayland"

  eval HAVE_PKG_QTWAYLAND=\"\!define HAVE_PKG_QTWAYLAND 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps qtwayland qtwayland"
    if test ! -z "qtbase"; then :
  for _appimage_i in qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i qtwayland"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-wayland-protocols was given.
if test "${enable_pkg_wayland_protocols+set}" = set; then :
  enableval=$enable_pkg_wayland_protocols; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package wayland-protocols" >&5
$as_echo_n "checking for package wayland-protocols... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='wayland-protocols-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for wayland-protocols in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for wayland-protocols in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for wayland-protocols in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources wayland-protocols";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_wayland_protocols=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_wayland_protocols_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_wayland_protocols_deps="qtwayland"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs wayland-protocols"

  eval HAVE_PKG_WAYLAND_PROTOCOLS=\"\!define HAVE_PKG_WAYLAND_PROTOCOLS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps wayland-protocols wayland-protocols"
    if test ! -z "qtwayland"; then :
  for _appimage_i in qtwayland; do
            _appimage_deps="$_appimage_deps $_appimage_i wayland-protocols"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-plasma-wayland-protocols was given.
if test "${enable_pkg_plasma_wayland_protocols+set}" = set; then :
  enableval=$enable_pkg_plasma_wayland_protocols; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package plasma-wayland-protocols" >&5
$as_echo_n "checking for package plasma-wayland-protocols... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='plasma-wayland-protocols-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for plasma-wayland-protocols in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for plasma-wayland-protocols in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for plasma-wayland-protocols in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources plasma-wayland-protocols";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_plasma_wayland_protocols=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_plasma_wayland_protocols_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_plasma_wayland_protocols_deps="wayland-protocols"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs plasma-wayland-protocols"

  eval HAVE_PKG_PLASMA_WAYLAND_PROTOCOLS=\"\!define HAVE_PKG_PLASMA_WAYLAND_PROTOCOLS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps plasma-wayland-protocols plasma-wayland-protocols"
    if test ! -z "wayland-protocols"; then :
  for _appimage_i in wayland-protocols; do
            _appimage_deps="$_appimage_deps $_appimage_i plasma-wayland-protocols"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-breeze was given.
if test "${enable_pkg_breeze+set}" = set; then :
  enableval=$enable_pkg_breeze; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package breeze" >&5
$as_echo_n "checking for package breeze... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='breeze-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for breeze in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for breeze in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for breeze in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources breeze";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_breeze=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_breeze_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_breeze_deps="qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs breeze"

  eval HAVE_PKG_BREEZE=\"\!define HAVE_PKG_BREEZE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps breeze breeze"
    if test ! -z "qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem"; then :
  for _appimage_i in qtbase kcoreaddons kconfig kconfigwidgets kguiaddons kiconthemes kwindowsystem; do
            _appimage_deps="$_appimage_deps $_appimage_i breeze"
          done
fi

fi


    # KDE Frameworks Tier 1


  _appimage_pkg=maybe
  # Check whether --enable-pkg-extra-cmake-modules was given.
if test "${enable_pkg_extra_cmake_modules+set}" = set; then :
  enableval=$enable_pkg_extra_cmake_modules; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package extra-cmake-modules" >&5
$as_echo_n "checking for package extra-cmake-modules... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='extra-cmake-modules-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for extra-cmake-modules in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for extra-cmake-modules in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for extra-cmake-modules in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources extra-cmake-modules";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_extra_cmake_modules=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_extra_cmake_modules_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_extra_cmake_modules_deps="qttools"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs extra-cmake-modules"

  eval HAVE_PKG_EXTRA_CMAKE_MODULES=\"\!define HAVE_PKG_EXTRA_CMAKE_MODULES 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps extra-cmake-modules extra-cmake-modules"
    if test ! -z "qttools"; then :
  for _appimage_i in qttools; do
            _appimage_deps="$_appimage_deps $_appimage_i extra-cmake-modules"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-breeze-icons was given.
if test "${enable_pkg_breeze_icons+set}" = set; then :
  enableval=$enable_pkg_breeze_icons; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package breeze-icons" >&5
$as_echo_n "checking for package breeze-icons... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='breeze-icons-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for breeze-icons in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for breeze-icons in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for breeze-icons in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources breeze-icons";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_breeze_icons=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_breeze_icons_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_breeze_icons_deps="extra-cmake-modules qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs breeze-icons"

  eval HAVE_PKG_BREEZE_ICONS=\"\!define HAVE_PKG_BREEZE_ICONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps breeze-icons breeze-icons"
    if test ! -z "extra-cmake-modules qtbase"; then :
  for _appimage_i in extra-cmake-modules qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i breeze-icons"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-karchive was given.
if test "${enable_pkg_karchive+set}" = set; then :
  enableval=$enable_pkg_karchive; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package karchive" >&5
$as_echo_n "checking for package karchive... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='karchive-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for karchive in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for karchive in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for karchive in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources karchive";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_karchive=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_karchive_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_karchive_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs karchive"

  eval HAVE_PKG_KARCHIVE=\"\!define HAVE_PKG_KARCHIVE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps karchive karchive"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i karchive"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kauth was given.
if test "${enable_pkg_kauth+set}" = set; then :
  enableval=$enable_pkg_kauth; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kauth" >&5
$as_echo_n "checking for package kauth... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kauth-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kauth in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kauth in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kauth in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kauth";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kauth=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kauth_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kauth_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kauth"

  eval HAVE_PKG_KAUTH=\"\!define HAVE_PKG_KAUTH 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kauth kauth"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kauth"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcodecs was given.
if test "${enable_pkg_kcodecs+set}" = set; then :
  enableval=$enable_pkg_kcodecs; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcodecs" >&5
$as_echo_n "checking for package kcodecs... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcodecs-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcodecs in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcodecs in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcodecs in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcodecs";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcodecs=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcodecs_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcodecs_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcodecs"

  eval HAVE_PKG_KCODECS=\"\!define HAVE_PKG_KCODECS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcodecs kcodecs"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kcodecs"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcolorscheme was given.
if test "${enable_pkg_kcolorscheme+set}" = set; then :
  enableval=$enable_pkg_kcolorscheme; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcolorscheme" >&5
$as_echo_n "checking for package kcolorscheme... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcolorscheme-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcolorscheme in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcolorscheme in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcolorscheme in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcolorscheme";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcolorscheme=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcolorscheme_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcolorscheme_deps="kconfig kguiaddons ki18n"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcolorscheme"

  eval HAVE_PKG_KCOLORSCHEME=\"\!define HAVE_PKG_KCOLORSCHEME 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcolorscheme kcolorscheme"
    if test ! -z "kconfig kguiaddons ki18n"; then :
  for _appimage_i in kconfig kguiaddons ki18n; do
            _appimage_deps="$_appimage_deps $_appimage_i kcolorscheme"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kconfig was given.
if test "${enable_pkg_kconfig+set}" = set; then :
  enableval=$enable_pkg_kconfig; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kconfig" >&5
$as_echo_n "checking for package kconfig... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kconfig-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kconfig in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kconfig in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kconfig in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kconfig";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kconfig=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kconfig_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kconfig_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kconfig"

  eval HAVE_PKG_KCONFIG=\"\!define HAVE_PKG_KCONFIG 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kconfig kconfig"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kconfig"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcoreaddons was given.
if test "${enable_pkg_kcoreaddons+set}" = set; then :
  enableval=$enable_pkg_kcoreaddons; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcoreaddons" >&5
$as_echo_n "checking for package kcoreaddons... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcoreaddons-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcoreaddons in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcoreaddons in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcoreaddons in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcoreaddons";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcoreaddons=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcoreaddons_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcoreaddons_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcoreaddons"

  eval HAVE_PKG_KCOREADDONS=\"\!define HAVE_PKG_KCOREADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcoreaddons kcoreaddons"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kcoreaddons"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kdbusaddons was given.
if test "${enable_pkg_kdbusaddons+set}" = set; then :
  enableval=$enable_pkg_kdbusaddons; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kdbusaddons" >&5
$as_echo_n "checking for package kdbusaddons... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kdbusaddons-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kdbusaddons in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kdbusaddons in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kdbusaddons in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kdbusaddons";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kdbusaddons=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kdbusaddons_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kdbusaddons_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kdbusaddons"

  eval HAVE_PKG_KDBUSADDONS=\"\!define HAVE_PKG_KDBUSADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kdbusaddons kdbusaddons"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kdbusaddons"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kguiaddons was given.
if test "${enable_pkg_kguiaddons+set}" = set; then :
  enableval=$enable_pkg_kguiaddons; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kguiaddons" >&5
$as_echo_n "checking for package kguiaddons... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kguiaddons-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kguiaddons in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kguiaddons in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kguiaddons in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kguiaddons";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kguiaddons=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kguiaddons_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kguiaddons_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kguiaddons"

  eval HAVE_PKG_KGUIADDONS=\"\!define HAVE_PKG_KGUIADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kguiaddons kguiaddons"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kguiaddons"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-ki18n was given.
if test "${enable_pkg_ki18n+set}" = set; then :
  enableval=$enable_pkg_ki18n; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package ki18n" >&5
$as_echo_n "checking for package ki18n... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='ki18n-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for ki18n in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for ki18n in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for ki18n in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources ki18n";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_ki18n=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_ki18n_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_ki18n_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs ki18n"

  eval HAVE_PKG_KI18N=\"\!define HAVE_PKG_KI18N 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps ki18n ki18n"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i ki18n"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kitemmodels was given.
if test "${enable_pkg_kitemmodels+set}" = set; then :
  enableval=$enable_pkg_kitemmodels; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kitemmodels" >&5
$as_echo_n "checking for package kitemmodels... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kitemmodels-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kitemmodels in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kitemmodels in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kitemmodels in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kitemmodels";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kitemmodels=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kitemmodels_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kitemmodels_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kitemmodels"

  eval HAVE_PKG_KITEMMODELS=\"\!define HAVE_PKG_KITEMMODELS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kitemmodels kitemmodels"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kitemmodels"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kitemviews was given.
if test "${enable_pkg_kitemviews+set}" = set; then :
  enableval=$enable_pkg_kitemviews; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kitemviews" >&5
$as_echo_n "checking for package kitemviews... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kitemviews-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kitemviews in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kitemviews in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kitemviews in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kitemviews";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kitemviews=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kitemviews_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kitemviews_deps="qtbase qttools extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kitemviews"

  eval HAVE_PKG_KITEMVIEWS=\"\!define HAVE_PKG_KITEMVIEWS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kitemviews kitemviews"
    if test ! -z "qtbase qttools extra-cmake-modules"; then :
  for _appimage_i in qtbase qttools extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kitemviews"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kwindowsystem was given.
if test "${enable_pkg_kwindowsystem+set}" = set; then :
  enableval=$enable_pkg_kwindowsystem; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kwindowsystem" >&5
$as_echo_n "checking for package kwindowsystem... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kwindowsystem-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kwindowsystem in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kwindowsystem in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kwindowsystem in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kwindowsystem";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kwindowsystem=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kwindowsystem_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kwindowsystem_deps="qtbase qtwayland extra-cmake-modules wayland-protocols plasma-wayland-protocols"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kwindowsystem"

  eval HAVE_PKG_KWINDOWSYSTEM=\"\!define HAVE_PKG_KWINDOWSYSTEM 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kwindowsystem kwindowsystem"
    if test ! -z "qtbase qtwayland extra-cmake-modules wayland-protocols plasma-wayland-protocols"; then :
  for _appimage_i in qtbase qtwayland extra-cmake-modules wayland-protocols plasma-wayland-protocols; do
            _appimage_deps="$_appimage_deps $_appimage_i kwindowsystem"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-solid was given.
if test "${enable_pkg_solid+set}" = set; then :
  enableval=$enable_pkg_solid; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package solid" >&5
$as_echo_n "checking for package solid... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='solid-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for solid in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for solid in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for solid in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources solid";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_solid=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_solid_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_solid_deps="qtbase extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs solid"

  eval HAVE_PKG_SOLID=\"\!define HAVE_PKG_SOLID 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps solid solid"
    if test ! -z "qtbase extra-cmake-modules"; then :
  for _appimage_i in qtbase extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i solid"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-sonnet was given.
if test "${enable_pkg_sonnet+set}" = set; then :
  enableval=$enable_pkg_sonnet; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package sonnet" >&5
$as_echo_n "checking for package sonnet... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='sonnet-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for sonnet in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for sonnet in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for sonnet in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources sonnet";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_sonnet=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_sonnet_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_sonnet_deps="qtbase extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs sonnet"

  eval HAVE_PKG_SONNET=\"\!define HAVE_PKG_SONNET 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps sonnet sonnet"
    if test ! -z "qtbase extra-cmake-modules"; then :
  for _appimage_i in qtbase extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i sonnet"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-threadweaver was given.
if test "${enable_pkg_threadweaver+set}" = set; then :
  enableval=$enable_pkg_threadweaver; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package threadweaver" >&5
$as_echo_n "checking for package threadweaver... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='threadweaver-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for threadweaver in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for threadweaver in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for threadweaver in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources threadweaver";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_threadweaver=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_threadweaver_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_threadweaver_deps="qtbase extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs threadweaver"

  eval HAVE_PKG_THREADWEAVER=\"\!define HAVE_PKG_THREADWEAVER 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps threadweaver threadweaver"
    if test ! -z "qtbase extra-cmake-modules"; then :
  for _appimage_i in qtbase extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i threadweaver"
          done
fi

fi


    # KDE Frameworks Tier 2


  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcompletion was given.
if test "${enable_pkg_kcompletion+set}" = set; then :
  enableval=$enable_pkg_kcompletion; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcompletion" >&5
$as_echo_n "checking for package kcompletion... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcompletion-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcompletion in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcompletion in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcompletion in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcompletion";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcompletion=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcompletion_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcompletion_deps="kwidgetsaddons"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcompletion"

  eval HAVE_PKG_KCOMPLETION=\"\!define HAVE_PKG_KCOMPLETION 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcompletion kcompletion"
    if test ! -z "kwidgetsaddons"; then :
  for _appimage_i in kwidgetsaddons; do
            _appimage_deps="$_appimage_deps $_appimage_i kcompletion"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcrash was given.
if test "${enable_pkg_kcrash+set}" = set; then :
  enableval=$enable_pkg_kcrash; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcrash" >&5
$as_echo_n "checking for package kcrash... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcrash-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcrash in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcrash in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcrash in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcrash";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcrash=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcrash_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcrash_deps="kwindowsystem kcoreaddons"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcrash"

  eval HAVE_PKG_KCRASH=\"\!define HAVE_PKG_KCRASH 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcrash kcrash"
    if test ! -z "kwindowsystem kcoreaddons"; then :
  for _appimage_i in kwindowsystem kcoreaddons; do
            _appimage_deps="$_appimage_deps $_appimage_i kcrash"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kjobwidgets was given.
if test "${enable_pkg_kjobwidgets+set}" = set; then :
  enableval=$enable_pkg_kjobwidgets; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kjobwidgets" >&5
$as_echo_n "checking for package kjobwidgets... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kjobwidgets-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kjobwidgets in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kjobwidgets in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kjobwidgets in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kjobwidgets";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kjobwidgets=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kjobwidgets_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kjobwidgets_deps="kwidgetsaddons kcoreaddons qtbase extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kjobwidgets"

  eval HAVE_PKG_KJOBWIDGETS=\"\!define HAVE_PKG_KJOBWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kjobwidgets kjobwidgets"
    if test ! -z "kwidgetsaddons kcoreaddons qtbase extra-cmake-modules"; then :
  for _appimage_i in kwidgetsaddons kcoreaddons qtbase extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kjobwidgets"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kstatusnotifieritem was given.
if test "${enable_pkg_kstatusnotifieritem+set}" = set; then :
  enableval=$enable_pkg_kstatusnotifieritem; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kstatusnotifieritem" >&5
$as_echo_n "checking for package kstatusnotifieritem... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kstatusnotifieritem-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kstatusnotifieritem in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kstatusnotifieritem in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kstatusnotifieritem in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kstatusnotifieritem";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kstatusnotifieritem=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kstatusnotifieritem_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kstatusnotifieritem_deps="kwindowsystem qtbase extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kstatusnotifieritem"

  eval HAVE_PKG_KSTATUSNOTIFIERITEM=\"\!define HAVE_PKG_KSTATUSNOTIFIERITEM 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kstatusnotifieritem kstatusnotifieritem"
    if test ! -z "kwindowsystem qtbase extra-cmake-modules"; then :
  for _appimage_i in kwindowsystem qtbase extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kstatusnotifieritem"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kwidgetsaddons was given.
if test "${enable_pkg_kwidgetsaddons+set}" = set; then :
  enableval=$enable_pkg_kwidgetsaddons; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kwidgetsaddons" >&5
$as_echo_n "checking for package kwidgetsaddons... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kwidgetsaddons-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kwidgetsaddons in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kwidgetsaddons in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kwidgetsaddons in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kwidgetsaddons";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kwidgetsaddons=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kwidgetsaddons_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kwidgetsaddons_deps="kconfig qttools qtbase"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kwidgetsaddons"

  eval HAVE_PKG_KWIDGETSADDONS=\"\!define HAVE_PKG_KWIDGETSADDONS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kwidgetsaddons kwidgetsaddons"
    if test ! -z "kconfig qttools qtbase"; then :
  for _appimage_i in kconfig qttools qtbase; do
            _appimage_deps="$_appimage_deps $_appimage_i kwidgetsaddons"
          done
fi

fi


    # KDE Frameworks Tier 3


  _appimage_pkg=maybe
  # Check whether --enable-pkg-kconfigwidgets was given.
if test "${enable_pkg_kconfigwidgets+set}" = set; then :
  enableval=$enable_pkg_kconfigwidgets; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kconfigwidgets" >&5
$as_echo_n "checking for package kconfigwidgets... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kconfigwidgets-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kconfigwidgets in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kconfigwidgets in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kconfigwidgets in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kconfigwidgets";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kconfigwidgets=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kconfigwidgets_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kconfigwidgets_deps="kwidgetsaddons kguiaddons ki18n kcodecs kconfig"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kconfigwidgets"

  eval HAVE_PKG_KCONFIGWIDGETS=\"\!define HAVE_PKG_KCONFIGWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kconfigwidgets kconfigwidgets"
    if test ! -z "kwidgetsaddons kguiaddons ki18n kcodecs kconfig"; then :
  for _appimage_i in kwidgetsaddons kguiaddons ki18n kcodecs kconfig; do
            _appimage_deps="$_appimage_deps $_appimage_i kconfigwidgets"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kiconthemes was given.
if test "${enable_pkg_kiconthemes+set}" = set; then :
  enableval=$enable_pkg_kiconthemes; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kiconthemes" >&5
$as_echo_n "checking for package kiconthemes... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kiconthemes-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kiconthemes in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kiconthemes in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kiconthemes in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kiconthemes";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kiconthemes=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kiconthemes_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kiconthemes_deps="qtsvg kconfigwidgets karchive"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kiconthemes"

  eval HAVE_PKG_KICONTHEMES=\"\!define HAVE_PKG_KICONTHEMES 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kiconthemes kiconthemes"
    if test ! -z "qtsvg kconfigwidgets karchive"; then :
  for _appimage_i in qtsvg kconfigwidgets karchive; do
            _appimage_deps="$_appimage_deps $_appimage_i kiconthemes"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-ktextwidgets was given.
if test "${enable_pkg_ktextwidgets+set}" = set; then :
  enableval=$enable_pkg_ktextwidgets; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package ktextwidgets" >&5
$as_echo_n "checking for package ktextwidgets... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='ktextwidgets-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for ktextwidgets in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for ktextwidgets in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for ktextwidgets in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources ktextwidgets";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_ktextwidgets=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_ktextwidgets_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_ktextwidgets_deps="sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs ktextwidgets"

  eval HAVE_PKG_KTEXTWIDGETS=\"\!define HAVE_PKG_KTEXTWIDGETS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps ktextwidgets ktextwidgets"
    if test ! -z "sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons"; then :
  for _appimage_i in sonnet kcompletion kconfig kconfigwidgets ki18n kwidgetsaddons; do
            _appimage_deps="$_appimage_deps $_appimage_i ktextwidgets"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kxmlgui was given.
if test "${enable_pkg_kxmlgui+set}" = set; then :
  enableval=$enable_pkg_kxmlgui; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kxmlgui" >&5
$as_echo_n "checking for package kxmlgui... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kxmlgui-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kxmlgui in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kxmlgui in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kxmlgui in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kxmlgui";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kxmlgui=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kxmlgui_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kxmlgui_deps="kiconthemes kconfigwidgets kitemviews ktextwidgets breeze"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kxmlgui"

  eval HAVE_PKG_KXMLGUI=\"\!define HAVE_PKG_KXMLGUI 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kxmlgui kxmlgui"
    if test ! -z "kiconthemes kconfigwidgets kitemviews ktextwidgets breeze"; then :
  for _appimage_i in kiconthemes kconfigwidgets kitemviews ktextwidgets breeze; do
            _appimage_deps="$_appimage_deps $_appimage_i kxmlgui"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kbookmarks was given.
if test "${enable_pkg_kbookmarks+set}" = set; then :
  enableval=$enable_pkg_kbookmarks; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kbookmarks" >&5
$as_echo_n "checking for package kbookmarks... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kbookmarks-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kbookmarks in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kbookmarks in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kbookmarks in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kbookmarks";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kbookmarks=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kbookmarks_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kbookmarks_deps="kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kbookmarks"

  eval HAVE_PKG_KBOOKMARKS=\"\!define HAVE_PKG_KBOOKMARKS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kbookmarks kbookmarks"
    if test ! -z "kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs"; then :
  for _appimage_i in kconfig kxmlgui kcoreaddons kconfigwidgets kwidgetsaddons kcodecs; do
            _appimage_deps="$_appimage_deps $_appimage_i kbookmarks"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kservice was given.
if test "${enable_pkg_kservice+set}" = set; then :
  enableval=$enable_pkg_kservice; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kservice" >&5
$as_echo_n "checking for package kservice... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kservice-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kservice in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kservice in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kservice in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kservice";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kservice=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kservice_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kservice_deps="kconfig kcoreaddons ki18n"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kservice"

  eval HAVE_PKG_KSERVICE=\"\!define HAVE_PKG_KSERVICE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kservice kservice"
    if test ! -z "kconfig kcoreaddons ki18n"; then :
  for _appimage_i in kconfig kcoreaddons ki18n; do
            _appimage_deps="$_appimage_deps $_appimage_i kservice"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kio was given.
if test "${enable_pkg_kio+set}" = set; then :
  enableval=$enable_pkg_kio; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kio" >&5
$as_echo_n "checking for package kio... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kio-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kio in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kio in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kio in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kio";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kio=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kio_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kio_deps="kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n kauth"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kio"

  eval HAVE_PKG_KIO=\"\!define HAVE_PKG_KIO 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kio kio"
    if test ! -z "kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n kauth"; then :
  for _appimage_i in kcrash kjobwidgets solid kservice kbookmarks kwidgetsaddons kxmlgui kwindowsystem karchive kconfig kcoreaddons ki18n kauth; do
            _appimage_deps="$_appimage_deps $_appimage_i kio"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kparts was given.
if test "${enable_pkg_kparts+set}" = set; then :
  enableval=$enable_pkg_kparts; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kparts" >&5
$as_echo_n "checking for package kparts... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kparts-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kparts in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kparts in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kparts in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kparts";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kparts=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kparts_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kparts_deps="kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kparts"

  eval HAVE_PKG_KPARTS=\"\!define HAVE_PKG_KPARTS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kparts kparts"
    if test ! -z "kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets"; then :
  for _appimage_i in kio kservice kxmlgui kconfigwidgets kwidgetsaddons ktextwidgets; do
            _appimage_deps="$_appimage_deps $_appimage_i kparts"
          done
fi

fi


    # KDE PIM


  _appimage_pkg=maybe
  # Check whether --enable-pkg-libical was given.
if test "${enable_pkg_libical+set}" = set; then :
  enableval=$enable_pkg_libical; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libical" >&5
$as_echo_n "checking for package libical... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libical-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libical in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libical in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libical in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libical";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libical=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libical_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libical_deps=""


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libical"

  eval HAVE_PKG_LIBICAL=\"\!define HAVE_PKG_LIBICAL 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libical libical"
    if test ! -z ""; then :
  for _appimage_i in ; do
            _appimage_deps="$_appimage_deps $_appimage_i libical"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kcalendarcore was given.
if test "${enable_pkg_kcalendarcore+set}" = set; then :
  enableval=$enable_pkg_kcalendarcore; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kcalendarcore" >&5
$as_echo_n "checking for package kcalendarcore... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kcalendarcore-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kcalendarcore in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kcalendarcore in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kcalendarcore in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kcalendarcore";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kcalendarcore=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kcalendarcore_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kcalendarcore_deps="qtbase libical extra-cmake-modules"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kcalendarcore"

  eval HAVE_PKG_KCALENDARCORE=\"\!define HAVE_PKG_KCALENDARCORE 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kcalendarcore kcalendarcore"
    if test ! -z "qtbase libical extra-cmake-modules"; then :
  for _appimage_i in qtbase libical extra-cmake-modules; do
            _appimage_deps="$_appimage_deps $_appimage_i kcalendarcore"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-mimetreeparser was given.
if test "${enable_pkg_mimetreeparser+set}" = set; then :
  enableval=$enable_pkg_mimetreeparser; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package mimetreeparser" >&5
$as_echo_n "checking for package mimetreeparser... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='mimetreeparser-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for mimetreeparser in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for mimetreeparser in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for mimetreeparser in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources mimetreeparser";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_mimetreeparser=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_mimetreeparser_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_mimetreeparser_deps="libkleo kwidgetsaddons ki18n kmime kcodecs kcalendarcore kmbox"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs mimetreeparser"

  eval HAVE_PKG_MIMETREEPARSER=\"\!define HAVE_PKG_MIMETREEPARSER 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps mimetreeparser mimetreeparser"
    if test ! -z "libkleo kwidgetsaddons ki18n kmime kcodecs kcalendarcore kmbox"; then :
  for _appimage_i in libkleo kwidgetsaddons ki18n kmime kcodecs kcalendarcore kmbox; do
            _appimage_deps="$_appimage_deps $_appimage_i mimetreeparser"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kmime was given.
if test "${enable_pkg_kmime+set}" = set; then :
  enableval=$enable_pkg_kmime; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kmime" >&5
$as_echo_n "checking for package kmime... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kmime-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kmime in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kmime in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kmime in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kmime";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kmime=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kmime_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kmime_deps="kcodecs ki18n"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kmime"

  eval HAVE_PKG_KMIME=\"\!define HAVE_PKG_KMIME 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kmime kmime"
    if test ! -z "kcodecs ki18n"; then :
  for _appimage_i in kcodecs ki18n; do
            _appimage_deps="$_appimage_deps $_appimage_i kmime"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-kmbox was given.
if test "${enable_pkg_kmbox+set}" = set; then :
  enableval=$enable_pkg_kmbox; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kmbox" >&5
$as_echo_n "checking for package kmbox... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kmbox-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kmbox in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kmbox in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kmbox in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kmbox";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kmbox=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kmbox_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kmbox_deps="kmime"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kmbox"

  eval HAVE_PKG_KMBOX=\"\!define HAVE_PKG_KMBOX 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kmbox kmbox"
    if test ! -z "kmime"; then :
  for _appimage_i in kmime; do
            _appimage_deps="$_appimage_deps $_appimage_i kmbox"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-libkleo was given.
if test "${enable_pkg_libkleo+set}" = set; then :
  enableval=$enable_pkg_libkleo; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package libkleo" >&5
$as_echo_n "checking for package libkleo... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='libkleo-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for libkleo in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for libkleo in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for libkleo in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources libkleo";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_libkleo=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_libkleo_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_libkleo_deps="kmime kconfigwidgets kwindowsystem kcompletion qgpgme"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs libkleo"

  eval HAVE_PKG_LIBKLEO=\"\!define HAVE_PKG_LIBKLEO 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps libkleo libkleo"
    if test ! -z "kmime kconfigwidgets kwindowsystem kcompletion qgpgme"; then :
  for _appimage_i in kmime kconfigwidgets kwindowsystem kcompletion qgpgme; do
            _appimage_deps="$_appimage_deps $_appimage_i libkleo"
          done
fi

fi




  _appimage_pkg=maybe
  # Check whether --enable-pkg-kleopatra was given.
if test "${enable_pkg_kleopatra+set}" = set; then :
  enableval=$enable_pkg_kleopatra; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package kleopatra" >&5
$as_echo_n "checking for package kleopatra... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='kleopatra-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for kleopatra in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for kleopatra in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for kleopatra in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources kleopatra";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_kleopatra=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_kleopatra_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_kleopatra_deps="mimetreeparser gnupg qgpgme breeze-icons kio kxmlgui libkleo kitemmodels qttranslations kdbusaddons kstatusnotifieritem"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs kleopatra"

  eval HAVE_PKG_KLEOPATRA=\"\!define HAVE_PKG_KLEOPATRA 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps kleopatra kleopatra"
    if test ! -z "mimetreeparser gnupg qgpgme breeze-icons kio kxmlgui libkleo kitemmodels qttranslations kdbusaddons kstatusnotifieritem"; then :
  for _appimage_i in mimetreeparser gnupg qgpgme breeze-icons kio kxmlgui libkleo kitemmodels qttranslations kdbusaddons kstatusnotifieritem; do
            _appimage_deps="$_appimage_deps $_appimage_i kleopatra"
          done
fi

fi


    # Okular/Poppler


  _appimage_pkg=maybe
  # Check whether --enable-pkg-poppler was given.
if test "${enable_pkg_poppler+set}" = set; then :
  enableval=$enable_pkg_poppler; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package poppler" >&5
$as_echo_n "checking for package poppler... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='poppler-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for poppler in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for poppler in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for poppler in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources poppler";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_poppler=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_poppler_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_poppler_deps="gpgmepp kio qtbase freetype"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs poppler"

  eval HAVE_PKG_POPPLER=\"\!define HAVE_PKG_POPPLER 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps poppler poppler"
    if test ! -z "gpgmepp kio qtbase freetype"; then :
  for _appimage_i in gpgmepp kio qtbase freetype; do
            _appimage_deps="$_appimage_deps $_appimage_i poppler"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-okular was given.
if test "${enable_pkg_okular+set}" = set; then :
  enableval=$enable_pkg_okular; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package okular" >&5
$as_echo_n "checking for package okular... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='okular-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for okular in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for okular in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for okular in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources okular";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_okular=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_okular_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_okular_deps="kparts gpgmepp kio poppler threadweaver qtsvg"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs okular"

  eval HAVE_PKG_OKULAR=\"\!define HAVE_PKG_OKULAR 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps okular okular"
    if test ! -z "kparts gpgmepp kio poppler threadweaver qtsvg"; then :
  for _appimage_i in kparts gpgmepp kio poppler threadweaver qtsvg; do
            _appimage_deps="$_appimage_deps $_appimage_i okular"
          done
fi

fi


    # Gpgpass


  _appimage_pkg=maybe
  # Check whether --enable-pkg-prison was given.
if test "${enable_pkg_prison+set}" = set; then :
  enableval=$enable_pkg_prison; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package prison" >&5
$as_echo_n "checking for package prison... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='prison-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for prison in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for prison in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for prison in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources prison";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_prison=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_prison_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_prison_deps="qtbase extra-cmake-modules qrencode"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs prison"

  eval HAVE_PKG_PRISON=\"\!define HAVE_PKG_PRISON 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps prison prison"
    if test ! -z "qtbase extra-cmake-modules qrencode"; then :
  for _appimage_i in qtbase extra-cmake-modules qrencode; do
            _appimage_deps="$_appimage_deps $_appimage_i prison"
          done
fi

fi



  _appimage_pkg=maybe
  # Check whether --enable-pkg-gpgpass was given.
if test "${enable_pkg_gpgpass+set}" = set; then :
  enableval=$enable_pkg_gpgpass; _appimage_pkg=$enableval
fi

  _appimage_kdepkg=no
  _appimage_version=
  if test "$_appimage_pkg" != no; then :




  appimage_val=
  appimage_version=

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for package gpgpass" >&5
$as_echo_n "checking for package gpgpass... " >&6; }
  _appimage_critical=no
  _appimage_file=
  _appimage_dir=$_appimage_pkg

  # If --enable-pkg-foo was specified, make success critical.
  if test x$_appimage_dir != xmaybe; then :
  _appimage_critical=yes
fi

  # Only check if critical or auto detection is requested.
  if test $_appimage_auto_detection = yes -o $_appimage_critical = yes; then :
  if test -z "$_appimage_dir" -o "$_appimage_dir" = yes -o "$_appimage_dir" = maybe; then :
  _appimage_dir=$appimage_packages
fi

    # Install pattern.
    if test -z ""; then :
  _appimage_pat='gpgpass-\([0-9].*\)'
else
  _appimage_pat=""
fi

    # Frob pattern.  Regex party!
    _appimage_glob=`echo "$_appimage_pat" | sed -e 's/\\\\(\(.*\)\\\\)/\1/'`
    _appimage_glob=`echo "$_appimage_glob" | sed -e 's/\\.\\*/*/'`

    # Make non-matching globs expand to nothing.
    shopt -s nullglob

    _appimage_format=both
    if test ! -z ""; then :
  _appimage_format=""
fi

    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.xz`
           _appimage_suffix=.tar.xz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.bz2`
           _appimage_suffix=.tar.bz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz2`
           _appimage_suffix=.tbz2
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tbz`
           _appimage_suffix=.tbz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tar.gz`
           _appimage_suffix=.tar.gz
fi
    if test -z "$_appimage_file" -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.tgz`
           _appimage_suffix=.tgz
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.zip`
           _appimage_suffix=.zip
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.exe`
           _appimage_suffix=.exe
fi
    if test -z "$_appimage_file" -a $_appimage_format != tar -a $_appimage_format != zip; then :
  _appimage_file=`echo ${_appimage_dir}/${_appimage_glob}.wixlib`
           _appimage_suffix=.wixlib
fi
    shopt -u nullglob
fi

  if test -z "$_appimage_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
else
  if test `echo $_appimage_file | head -c 1` != /; then :
  _appimage_file=`pwd`/$_appimage_file
fi
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_appimage_file" >&5
$as_echo "$_appimage_file" >&6; }
fi
  if test -z "$_appimage_file" -a $_appimage_critical = yes; then :
  as_fn_error $? "could not find sources for gpgpass in $_appimage_dir" "$LINENO" 5
fi

  # Test for duplicate.
  _appimage_found=
  for _appimage_f in $_appimage_file; do
      if test "$_appimage_found" = yes; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: found more than one sources for gpgpass in $_appimage_dir" >&5
$as_echo "$as_me: WARNING: found more than one sources for gpgpass in $_appimage_dir" >&2;}
             appimage_dup_sources="$appimage_dup_sources gpgpass";
             appimage_rm_candidates="$appimage_rm_candidates $_appimage_file"
fi
      _appimage_found=yes
  done

  if test ! -z "$_appimage_file"; then :
  appimage_val="$_appimage_file"
        appimage_version=`echo "$appimage_val" | sed -e "s,^.*/${_appimage_pat}${_appimage_suffix}$,\1,"`
         _appimage_kdepkg=$appimage_val
        _appimage_version=$appimage_version
fi

fi

  # appimage_pkg_PKGNAME=FILENAME_OF_SOURCE
  appimage_pkg_gpgpass=$_appimage_kdepkg


  # appimage_pkg_PKGNAME_version=VERSION
  appimage_pkg_gpgpass_version=$_appimage_version


  # appimage_pkg_PKGNAME_deps=DEPS
  appimage_pkg_gpgpass_deps="kio prison kconfigwidgets kiconthemes ki18n qgpgme"


  if test "$_appimage_kdepkg" != no; then :
  _appimage_pkgs="$_appimage_pkgs gpgpass"

  eval HAVE_PKG_GPGPASS=\"\!define HAVE_PKG_GPGPASS 1\"


    # Record dependencies.  Also enter every package as node.
    _appimage_deps="$_appimage_deps gpgpass gpgpass"
    if test ! -z "kio prison kconfigwidgets kiconthemes ki18n qgpgme"; then :
  for _appimage_i in kio prison kconfigwidgets kiconthemes ki18n qgpgme; do
            _appimage_deps="$_appimage_deps $_appimage_i gpgpass"
          done
fi

fi


  { $as_echo "$as_me:${as_lineno-$LINENO}: checking build list" >&5
$as_echo_n "checking build list... " >&6; }
  appimage_build_list=`echo $_appimage_deps | tsort`
  # Remove newlines.
  appimage_build_list=`echo $appimage_build_list`
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $appimage_build_list" >&5
$as_echo "$appimage_build_list" >&6; }


  # Check each dependency.
  _appimage_not_found=
  _appimage_d=
  _appimage_p=
  for _appimage_p in $_appimage_deps; do
    if test -z $_appimage_d; then :
  _appimage_d=$_appimage_p
else

            _appimage_found=
            for _appimage_i in $_appimage_pkgs; do
              if test $_appimage_d = $_appimage_i; then :
  _appimage_found=yes
                    break
fi
            done
            if test -z $_appimage_found; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: could not find package $_appimage_d required by package $_appimage_p" >&5
$as_echo "$as_me: WARNING: could not find package $_appimage_d required by package $_appimage_p" >&2;}
                  _appimage_not_found=yes
fi
            _appimage_d=

fi
  done
  if test ! -z "$_appimage_not_found"; then :
  as_fn_error $? "could not find some required packages" "$LINENO" 5
fi




  _appimage_debug=no
  # Check whether --enable-debug was given.
if test "${enable_debug+set}" = set; then :
  enableval=$enable_debug; _appimage_debug=$enableval
fi


  if test "${_appimage_debug}" != no; then :

  eval APPIMAGE_DEBUG=\"\!define APPIMAGE_DEBUG 1\"


fi

fi

# Throw an error if required tools are missing
if test -n "$missing_tools"; then
    for i in $missing_tools; do
      { $as_echo "$as_me:${as_lineno-$LINENO}: $i is missing" >&5
$as_echo "$as_me: $i is missing" >&6;}
    done
    as_fn_error $? "
***
*** Required tools not found. Please consult the above messages
*** and install them before running configure again.
***" "$LINENO" 5
fi

# Throw an error if any duplicate source packages have been found The
# packages_dirpfx is set depending on whether we are running under
# docker.  See also GPG4WIN_PACKAGES.
packages_dirpfx=
test -f /src/packages/BUILDTYPE && packages_dirpfx=/src/
packages_files=${packages_dirpfx}packages/packages.list
if test -n "$gpg4win_dup_sources"; then
    tmp=
    for i in $gpg4win_dup_sources; do
      tmp="$tmp
$i"
    done
    tmp2="
You might remove them with:"
    for i in $gpg4win_rm_candidates; do
        if ! grep -q $(basename $i) $packages_files; then
            tmp2="$tmp2
rm $i"
        fi
    done
    as_fn_error $? "Packages with more that one source version:$tmp$tmp2" "$LINENO" 5
fi

if test -n "$appimage_dup_sources"; then
    tmp=
    for i in $appimage_dup_sources; do
      tmp="$tmp
$i"
    done
    tmp2="
You might remove them with:"
    for i in $appimage_rm_candidates; do
        if ! grep -q $(basename $i) $packages_files; then
            tmp2="$tmp2
rm $i"
        fi
    done
    as_fn_error $? "Packages with more that one source version:$tmp$tmp2" "$LINENO" 5
fi

# Finalize.

ac_config_files="$ac_config_files Makefile"

ac_config_files="$ac_config_files packages/Makefile src/Makefile po/Makefile"

ac_config_files="$ac_config_files src/nsis/config.nsi src/gpg4win.mk"

ac_config_files="$ac_config_files doc/Makefile"

ac_config_files="$ac_config_files doc/logo/Makefile"

ac_config_files="$ac_config_files src/toolchain.cmake"

ac_config_files="$ac_config_files src/toolchain-ex.cmake"

ac_config_files="$ac_config_files src/toolchain-native.cmake"

ac_config_files="$ac_config_files src/appimage/Makefile src/appimage/appimage.mk"

ac_config_files="$ac_config_files src/appimage/rsync-filters/Makefile"

ac_config_files="$ac_config_files src/nsis/Makefile"

ac_config_files="$ac_config_files src/versioninfo.rc.in"

ac_config_files="$ac_config_files src/gpg4win.w32-manifest.in"


ac_config_files="$ac_config_files src/gccwrap.sh"

ac_config_commands="$ac_config_commands chmod"


cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
# scripts and configure runs, see configure's option --config-cache.
# It is not useful on other systems.  If it contains results you don't
# want to keep, you may remove or edit it.
#
# config.status only pays attention to the cache file if you give it
# the --recheck option to rerun configure.
#
# `ac_cv_env_foo' variables (set or unset) will be overridden when
# loading this file, other *unset* `ac_cv_foo' will be assigned the
# following values.

_ACEOF

# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done

  (set) 2>&1 |
    case $as_nl`(ac_space=' '; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      # `set' does not quote correctly, so add quotes: double-quote
      # substitution turns \\\\ into \\, and sed turns \\ into \.
      sed -n \
	"s/'/'\\\\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
      ;; #(
    *)
      # `set' quotes correctly as required by POSIX, so do not add quotes.
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
) |
  sed '
     /^ac_cv_env_/b end
     t clear
     :clear
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
     t end
     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
     :end' >>confcache
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
  if test -w "$cache_file"; then
    if test "x$cache_file" != "x/dev/null"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
$as_echo "$as_me: updating cache $cache_file" >&6;}
      if test ! -f "$cache_file" || test -h "$cache_file"; then
	cat confcache >"$cache_file"
      else
        case $cache_file in #(
        */* | ?:*)
	  mv -f confcache "$cache_file"$$ &&
	  mv -f "$cache_file"$$ "$cache_file" ;; #(
        *)
	  mv -f confcache "$cache_file" ;;
	esac
      fi
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
  fi
fi
rm -f confcache

test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

DEFS=-DHAVE_CONFIG_H

ac_libobjs=
ac_ltlibobjs=
U=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
  # 1. Remove the extension, and $U if already installed.
  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
  #    will be set to the directory where LIBOBJS objects are built.
  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
$as_echo_n "checking that generated files are newer than configure... " >&6; }
   if test -n "$am_sleep_pid"; then
     # Hide warnings about reused PIDs.
     wait $am_sleep_pid 2>/dev/null
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
$as_echo "done" >&6; }
 if test -n "$EXEEXT"; then
  am__EXEEXT_TRUE=
  am__EXEEXT_FALSE='#'
else
  am__EXEEXT_TRUE='#'
  am__EXEEXT_FALSE=
fi

if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${DOCKERBUILD_TRUE}" && test -z "${DOCKERBUILD_FALSE}"; then
  as_fn_error $? "conditional \"DOCKERBUILD\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${BUILD_GPG4WIN_TRUE}" && test -z "${BUILD_GPG4WIN_FALSE}"; then
  as_fn_error $? "conditional \"BUILD_GPG4WIN\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${BUILD_APPIMAGE_TRUE}" && test -z "${BUILD_APPIMAGE_FALSE}"; then
  as_fn_error $? "conditional \"BUILD_APPIMAGE\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${BUILD_W64_COND_TRUE}" && test -z "${BUILD_W64_COND_FALSE}"; then
  as_fn_error $? "conditional \"BUILD_W64_COND\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
  as_fn_error $? "conditional \"AMDEP\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi

: "${CONFIG_STATUS=./config.status}"
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false

SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error


# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null


# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi


# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by gpg4win $as_me 5.0.0-beta395, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

on `(hostname || uname -n) 2>/dev/null | sed 1q`
"

_ACEOF

case $ac_config_files in *"
"*) set x $ac_config_files; shift; ac_config_files=$*;;
esac

case $ac_config_headers in *"
"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
esac


cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
config_headers="$ac_config_headers"
config_commands="$ac_config_commands"

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration.  Unless the files
and actions are specified as TAGs, all are instantiated by default.

Usage: $0 [OPTION]... [TAG]...

  -h, --help       print this help, then exit
  -V, --version    print version number and configuration settings, then exit
      --config     print configuration, then exit
  -q, --quiet, --silent
                   do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
      --file=FILE[:TEMPLATE]
                   instantiate the configuration file FILE
      --header=FILE[:TEMPLATE]
                   instantiate the configuration header FILE

Configuration files:
$config_files

Configuration headers:
$config_headers

Configuration commands:
$config_commands

Report bugs to <https://bugs.gnupg.org>."

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
gpg4win config.status 5.0.0-beta395
configured by $0, generated by GNU Autoconf 2.69,
  with options \\"\$ac_cs_config\\"

Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."

ac_pwd='$ac_pwd'
srcdir='$srcdir'
INSTALL='$INSTALL'
MKDIR_P='$MKDIR_P'
AWK='$AWK'
test -n "\$AWK" || AWK=awk
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=?*)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  --*=)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=
    ac_shift=:
    ;;
  *)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  esac

  case $ac_option in
  # Handling of the options.
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
    $as_echo "$ac_cs_version"; exit ;;
  --config | --confi | --conf | --con | --co | --c )
    $as_echo "$ac_cs_config"; exit ;;
  --debug | --debu | --deb | --de | --d | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    '') as_fn_error $? "missing file argument" ;;
    esac
    as_fn_append CONFIG_FILES " '$ac_optarg'"
    ac_need_defaults=false;;
  --header | --heade | --head | --hea )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
    ac_need_defaults=false;;
  --he | --h)
    # Conflict between --help and --header
    as_fn_error $? "ambiguous option: \`$1'
Try \`$0 --help' for more information.";;
  --help | --hel | -h )
    $as_echo "$ac_cs_usage"; exit ;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) as_fn_error $? "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;

  *) as_fn_append ac_config_targets " $1"
     ac_need_defaults=false ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
  shift
  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
  CONFIG_SHELL='$SHELL'
  export CONFIG_SHELL
  exec "\$@"
fi

_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
  $as_echo "$ac_log"
} >&5

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
#
# INIT-COMMANDS
#
AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1

# Handling of arguments.
for ac_config_target in $ac_config_targets
do
  case $ac_config_target in
    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
    "packages/Makefile") CONFIG_FILES="$CONFIG_FILES packages/Makefile" ;;
    "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
    "po/Makefile") CONFIG_FILES="$CONFIG_FILES po/Makefile" ;;
    "src/nsis/config.nsi") CONFIG_FILES="$CONFIG_FILES src/nsis/config.nsi" ;;
    "src/gpg4win.mk") CONFIG_FILES="$CONFIG_FILES src/gpg4win.mk" ;;
    "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
    "doc/logo/Makefile") CONFIG_FILES="$CONFIG_FILES doc/logo/Makefile" ;;
    "src/toolchain.cmake") CONFIG_FILES="$CONFIG_FILES src/toolchain.cmake" ;;
    "src/toolchain-ex.cmake") CONFIG_FILES="$CONFIG_FILES src/toolchain-ex.cmake" ;;
    "src/toolchain-native.cmake") CONFIG_FILES="$CONFIG_FILES src/toolchain-native.cmake" ;;
    "src/appimage/Makefile") CONFIG_FILES="$CONFIG_FILES src/appimage/Makefile" ;;
    "src/appimage/appimage.mk") CONFIG_FILES="$CONFIG_FILES src/appimage/appimage.mk" ;;
    "src/appimage/rsync-filters/Makefile") CONFIG_FILES="$CONFIG_FILES src/appimage/rsync-filters/Makefile" ;;
    "src/nsis/Makefile") CONFIG_FILES="$CONFIG_FILES src/nsis/Makefile" ;;
    "src/versioninfo.rc.in") CONFIG_FILES="$CONFIG_FILES src/versioninfo.rc.in" ;;
    "src/gpg4win.w32-manifest.in") CONFIG_FILES="$CONFIG_FILES src/gpg4win.w32-manifest.in" ;;
    "src/gccwrap.sh") CONFIG_FILES="$CONFIG_FILES src/gccwrap.sh" ;;
    "chmod") CONFIG_COMMANDS="$CONFIG_COMMANDS chmod" ;;

  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
  esac
done


# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
  tmp= ac_tmp=
  trap 'exit_status=$?
  : "${ac_tmp:=$tmp}"
  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
' 0
  trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
  test -d "$tmp"
}  ||
{
  tmp=./conf$$-$RANDOM
  (umask 077 && mkdir "$tmp")
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
ac_tmp=$tmp

# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then


ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
  eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
  ac_cs_awk_cr='\\r'
else
  ac_cs_awk_cr=$ac_cr
fi

echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
_ACEOF


{
  echo "cat >conf$$subs.awk <<_ACEOF" &&
  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
  echo "_ACEOF"
} >conf$$subs.sh ||
  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
  . ./conf$$subs.sh ||
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5

  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
  if test $ac_delim_n = $ac_delim_num; then
    break
  elif $ac_last_try; then
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done
rm -f conf$$subs.sh

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
h
s/^/S["/; s/!.*/"]=/
p
g
s/^[^!]*!//
:repl
t repl
s/'"$ac_delim"'$//
t delim
:nl
h
s/\(.\{148\}\)..*/\1/
t more1
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
p
n
b repl
:more1
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t nl
:delim
h
s/\(.\{148\}\)..*/\1/
t more2
s/["\\]/\\&/g; s/^/"/; s/$/"/
p
b
:more2
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t delim
' <conf$$subs.awk | sed '
/^[^""]/{
  N
  s/\n//
}
' >>$CONFIG_STATUS || ac_write_fail=1
rm -f conf$$subs.awk
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
  for (key in S) S_is_set[key] = 1
  FS = ""

}
{
  line = $ 0
  nfields = split(line, field, "@")
  substed = 0
  len = length(field[1])
  for (i = 2; i < nfields; i++) {
    key = field[i]
    keylen = length(key)
    if (S_is_set[key]) {
      value = S[key]
      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
      len += length(value) + length(field[++i])
      substed = 1
    } else
      len += 1 + keylen
  }

  print line
}

_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
  cat
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
_ACEOF

# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
# trailing colons and then remove the whole line if VPATH becomes empty
# (actually we leave an empty line to preserve line numbers).
if test "x$srcdir" = x.; then
  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
h
s///
s/^/:/
s/[	 ]*$/:/
s/:\$(srcdir):/:/g
s/:\${srcdir}:/:/g
s/:@srcdir@:/:/g
s/^:*//
s/:*$//
x
s/\(=[	 ]*\).*/\1/
G
s/\n//
s/^[^=]*=[	 ]*$//
}'
fi

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"

# Set up the scripts for CONFIG_HEADERS section.
# No need to generate them if there are no CONFIG_HEADERS.
# This happens for instance with `./config.status Makefile'.
if test -n "$CONFIG_HEADERS"; then
cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
BEGIN {
_ACEOF

# Transform confdefs.h into an awk script `defines.awk', embedded as
# here-document in config.status, that substitutes the proper values into
# config.h.in to produce config.h.

# Create a delimiter string that does not exist in confdefs.h, to ease
# handling of long lines.
ac_delim='%!_!# '
for ac_last_try in false false :; do
  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
  if test -z "$ac_tt"; then
    break
  elif $ac_last_try; then
    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done

# For the awk script, D is an array of macro values keyed by name,
# likewise P contains macro parameters if any.  Preserve backslash
# newline sequences.

ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
sed -n '
s/.\{148\}/&'"$ac_delim"'/g
t rset
:rset
s/^[	 ]*#[	 ]*define[	 ][	 ]*/ /
t def
d
:def
s/\\$//
t bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3"/p
s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2"/p
d
:bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3\\\\\\n"\\/p
t cont
s/^ \('"$ac_word_re"'\)[	 ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
t cont
d
:cont
n
s/.\{148\}/&'"$ac_delim"'/g
t clear
:clear
s/\\$//
t bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/"/p
d
:bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
b cont
' <confdefs.h | sed '
s/'"$ac_delim"'/"\\\
"/g' >>$CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  for (key in D) D_is_set[key] = 1
  FS = ""
}
/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
  line = \$ 0
  split(line, arg, " ")
  if (arg[1] == "#") {
    defundef = arg[2]
    mac1 = arg[3]
  } else {
    defundef = substr(arg[1], 2)
    mac1 = arg[2]
  }
  split(mac1, mac2, "(") #)
  macro = mac2[1]
  prefix = substr(line, 1, index(line, defundef) - 1)
  if (D_is_set[macro]) {
    # Preserve the white space surrounding the "#".
    print prefix "define", macro P[macro] D[macro]
    next
  } else {
    # Replace #undef with comments.  This is necessary, for example,
    # in the case of _POSIX_SOURCE, which is predefined and required
    # on some systems where configure will not decide to define it.
    if (defundef == "undef") {
      print "/*", prefix defundef, macro, "*/"
      next
    }
  }
}
{ print }
_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
fi # test -n "$CONFIG_HEADERS"


eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
shift
for ac_tag
do
  case $ac_tag in
  :[FHLC]) ac_mode=$ac_tag; continue;;
  esac
  case $ac_mode$ac_tag in
  :[FHL]*:*);;
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
  :[FH]-) ac_tag=-:-;;
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
  esac
  ac_save_IFS=$IFS
  IFS=:
  set x $ac_tag
  IFS=$ac_save_IFS
  shift
  ac_file=$1
  shift

  case $ac_mode in
  :L) ac_source=$1;;
  :[FH])
    ac_file_inputs=
    for ac_f
    do
      case $ac_f in
      -) ac_f="$ac_tmp/stdin";;
      *) # Look for the file first in the build tree, then in the source tree
	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
	 # because $ac_f cannot contain `:'.
	 test -f "$ac_f" ||
	   case $ac_f in
	   [\\/$]*) false;;
	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
	   esac ||
	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
      esac
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
      as_fn_append ac_file_inputs " '$ac_f'"
    done

    # Let's still pretend it is `configure' which instantiates (i.e., don't
    # use $as_me), people would be surprised to read:
    #    /* config.h.  Generated by config.status.  */
    configure_input='Generated from '`
	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
	`' by configure.'
    if test x"$ac_file" != x-; then
      configure_input="$ac_file.  $configure_input"
      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
$as_echo "$as_me: creating $ac_file" >&6;}
    fi
    # Neutralize special characters interpreted by sed in replacement strings.
    case $configure_input in #(
    *\&* | *\|* | *\\* )
       ac_sed_conf_input=`$as_echo "$configure_input" |
       sed 's/[\\\\&|]/\\\\&/g'`;; #(
    *) ac_sed_conf_input=$configure_input;;
    esac

    case $ac_tag in
    *:-:* | *:-) cat >"$ac_tmp/stdin" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
    esac
    ;;
  esac

  ac_dir=`$as_dirname -- "$ac_file" ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ac_file" : 'X\(//\)[^/]' \| \
	 X"$ac_file" : 'X\(//\)$' \| \
	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ac_file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  as_dir="$ac_dir"; as_fn_mkdir_p
  ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix


  case $ac_mode in
  :F)
  #
  # CONFIG_FILE
  #

  case $INSTALL in
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
  esac
  ac_MKDIR_P=$MKDIR_P
  case $MKDIR_P in
  [\\/$]* | ?:[\\/]* ) ;;
  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
  esac
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
  p
  q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  ac_datarootdir_hack='
  s&@datadir@&$datadir&g
  s&@docdir@&$docdir&g
  s&@infodir@&$infodir&g
  s&@localedir@&$localedir&g
  s&@mandir@&$mandir&g
  s&\\\${datarootdir}&$datarootdir&g' ;;
esac
_ACEOF

# Neutralize VPATH when `$srcdir' = `.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
$extrasub
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
s&@INSTALL@&$ac_INSTALL&;t t
s&@MKDIR_P@&$ac_MKDIR_P&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5

test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
      "$ac_tmp/out"`; test -z "$ac_out"; } &&
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&5
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&2;}

  rm -f "$ac_tmp/stdin"
  case $ac_file in
  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
  esac \
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 ;;
  :H)
  #
  # CONFIG_HEADER
  #
  if test x"$ac_file" != x-; then
    {
      $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
    } >"$ac_tmp/config.h" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
$as_echo "$as_me: $ac_file is unchanged" >&6;}
    else
      rm -f "$ac_file"
      mv "$ac_tmp/config.h" "$ac_file" \
	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
    fi
  else
    $as_echo "/* $configure_input  */" \
      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
      || as_fn_error $? "could not create -" "$LINENO" 5
  fi
# Compute "$ac_file"'s index in $config_headers.
_am_arg="$ac_file"
_am_stamp_count=1
for _am_header in $config_headers :; do
  case $_am_header in
    $_am_arg | $_am_arg:* )
      break ;;
    * )
      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
  esac
done
echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$_am_arg" : 'X\(//\)[^/]' \| \
	 X"$_am_arg" : 'X\(//\)$' \| \
	 X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$_am_arg" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`/stamp-h$_am_stamp_count
 ;;

  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
$as_echo "$as_me: executing $ac_file commands" >&6;}
 ;;
  esac


  case $ac_file$ac_mode in
    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
  # Older Autoconf quotes --file arguments for eval, but not when files
  # are listed without --file.  Let's play safe and only enable the eval
  # if we detect the quoting.
  # TODO: see whether this extra hack can be removed once we start
  # requiring Autoconf 2.70 or later.
  case $CONFIG_FILES in #(
  *\'*) :
    eval set x "$CONFIG_FILES" ;; #(
  *) :
    set x $CONFIG_FILES ;; #(
  *) :
     ;;
esac
  shift
  # Used to flag and report bootstrapping failures.
  am_rc=0
  for am_mf
  do
    # Strip MF so we end up with the name of the file.
    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
    # Check whether this is an Automake generated Makefile which includes
    # dependency-tracking related rules and includes.
    # Grep'ing the whole file directly is not great: AIX grep has a line
    # limit of 2048, but all sed's we know have understand at least 4000.
    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
      || continue
    am_dirpart=`$as_dirname -- "$am_mf" ||
$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$am_mf" : 'X\(//\)[^/]' \| \
	 X"$am_mf" : 'X\(//\)$' \| \
	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$am_mf" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
    am_filepart=`$as_basename -- "$am_mf" ||
$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$am_mf" : 'X\(//\)$' \| \
	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$am_mf" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
    { echo "$as_me:$LINENO: cd "$am_dirpart" \
      && sed -e '/# am--include-marker/d' "$am_filepart" \
        | $MAKE -f - am--depfiles" >&5
   (cd "$am_dirpart" \
      && sed -e '/# am--include-marker/d' "$am_filepart" \
        | $MAKE -f - am--depfiles) >&5 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } || am_rc=$?
  done
  if test $am_rc -ne 0; then
    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "Something went wrong bootstrapping makefile fragments
    for automatic dependency tracking.  If GNU make was not used, consider
    re-running the configure script with MAKE=\"gmake\" (or whatever is
    necessary).  You can also try re-running configure with the
    '--disable-dependency-tracking' option to at least be able to build
    the package (albeit without support for automatic dependency tracking).
See \`config.log' for more details" "$LINENO" 5; }
  fi
  { am_dirpart=; unset am_dirpart;}
  { am_filepart=; unset am_filepart;}
  { am_mf=; unset am_mf;}
  { am_rc=; unset am_rc;}
  rm -f conftest-deps.mk
}
 ;;
    "chmod":C) chmod +x src/gccwrap.sh ;;

  esac
done # for ac_tag


as_fn_exit 0
_ACEOF
ac_clean_files=$ac_clean_files_save

test $ac_write_fail = 0 ||
  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5


# configure is writing to config.log, and then calls config.status.
# config.status does its own redirection, appending to config.log.
# Unfortunately, on DOS this fails, as config.log is still kept open
# by configure, so config.status won't be able to write to it; its
# output is simply discarded.  So we exec the FD to /dev/null,
# effectively closing config.log, so it can be properly (re)opened and
# appended to by config.status.  When coming back to configure, we
# need to make the FD available again.
if test "$no_create" != yes; then
  ac_cs_success=:
  ac_config_status_args=
  test "$silent" = yes &&
    ac_config_status_args="$ac_config_status_args --quiet"
  exec 5>/dev/null
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
  exec 5>>config.log
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
  # would make configure fail if this is the last instruction.
  $ac_cs_success || as_fn_exit 1
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi


# Throw a warning if optional tools are missing
if test -n "$missing_opt_tools"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING:
***
*** Some tools not found.  They may or may not be needed depending on
*** the packages you want to include.  For example GLIB and GTK+
*** require certain tools; you may need to install a recent version of
*** GLIB and GTK+ on the build machine to allow for cross-compiling.
***" >&5
$as_echo "$as_me: WARNING:
***
*** Some tools not found.  They may or may not be needed depending on
*** the packages you want to include.  For example GLIB and GTK+
*** require certain tools; you may need to install a recent version of
*** GLIB and GTK+ on the build machine to allow for cross-compiling.
***" >&2;}
    for i in $missing_opt_tools; do
      { $as_echo "$as_me:${as_lineno-$LINENO}: $i is missing" >&5
$as_echo "$as_me: $i is missing" >&6;}
    done
fi

echo -n "
        $PACKAGE_NAME-$PACKAGE_VERSION prepared for make

        Revision .....: ${GIT_REVISION}  (${GIT_REVISION_DEC})
        Main platform : $host
        Extra platform: ${GPGEX_ADD_HOST}
        Distribution .: ${PRODUCT_NAME} (gpg4win)
        Source dir ...: ${TOPSRCDIR}
        Build dir ....: ${PLAYGROUND}
"
if test -n "$JOBS"; then
    echo "        make jobs ....: ${JOBS}"
else
    echo ""
fi
