path: root/python/guestfs-py.c

/* libguestfs generated file
 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
 *
 * Copyright (C) 2009 Red Hat Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include <Python.h>

#include "guestfs.h"

typedef struct {
  PyObject_HEAD
  guestfs_h *g;
} Pyguestfs_Object;

static guestfs_h *
get_handle (PyObject *obj)
{
  assert (obj);
  assert (obj != Py_None);
  return ((Pyguestfs_Object *) obj)->g;
}

static PyObject *
put_handle (guestfs_h *g)
{
  assert (g);
  return
    PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) "guestfs_h", NULL);
}

/* This list should be freed (but not the strings) after use. */
static const char **
get_string_list (PyObject *obj)
{
  int i, len;
  const char **r;

  assert (obj);

  if (!PyList_Check (obj)) {
    PyErr_SetString (PyExc_RuntimeError, "expecting a list parameter");
    return NULL;
  }

  len = PyList_Size (obj);
  r = malloc (sizeof (char *) * (len+1));
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, "get_string_list: out of memory");
    return NULL;
  }

  for (i = 0; i < len; ++i)
    r[i] = PyString_AsString (PyList_GetItem (obj, i));
  r[len] = NULL;

  return r;
}

static PyObject *
put_string_list (char * const * const argv)
{
  PyObject *list;
  int argc, i;

  for (argc = 0; argv[argc] != NULL; ++argc)
    ;

  list = PyList_New (argc);
  for (i = 0; i < argc; ++i)
    PyList_SetItem (list, i, PyString_FromString (argv[i]));

  return list;
}

static PyObject *
put_table (char * const * const argv)
{
  PyObject *list, *item;
  int argc, i;

  for (argc = 0; argv[argc] != NULL; ++argc)
    ;

  list = PyList_New (argc >> 1);
  for (i = 0; i < argc; i += 2) {
    item = PyTuple_New (2);
    PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
    PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
    PyList_SetItem (list, i >> 1, item);
  }

  return list;
}

static void
free_strings (char **argv)
{
  int argc;

  for (argc = 0; argv[argc] != NULL; ++argc)
    free (argv[argc]);
  free (argv);
}

static PyObject *
py_guestfs_create (PyObject *self, PyObject *args)
{
  guestfs_h *g;

  g = guestfs_create ();
  if (g == NULL) {
    PyErr_SetString (PyExc_RuntimeError,
                     "guestfs.create: failed to allocate handle");
    return NULL;
  }
  guestfs_set_error_handler (g, NULL, NULL);
  return put_handle (g);
}

static PyObject *
py_guestfs_close (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
    return NULL;
  g = get_handle (py_g);

  guestfs_close (g);

  Py_INCREF (Py_None);
  return Py_None;
}

static PyObject *
put_lvm_pv (struct guestfs_lvm_pv *pv)
{
  PyObject *dict;

  dict = PyDict_New ();
  PyDict_SetItemString (dict, "pv_name",
                        PyString_FromString (pv->pv_name));
  PyDict_SetItemString (dict, "pv_uuid",
                        PyString_FromStringAndSize (pv->pv_uuid, 32));
  PyDict_SetItemString (dict, "pv_fmt",
                        PyString_FromString (pv->pv_fmt));
  PyDict_SetItemString (dict, "pv_size",
                        PyLong_FromUnsignedLongLong (pv->pv_size));
  PyDict_SetItemString (dict, "dev_size",
                        PyLong_FromUnsignedLongLong (pv->dev_size));
  PyDict_SetItemString (dict, "pv_free",
                        PyLong_FromUnsignedLongLong (pv->pv_free));
  PyDict_SetItemString (dict, "pv_used",
                        PyLong_FromUnsignedLongLong (pv->pv_used));
  PyDict_SetItemString (dict, "pv_attr",
                        PyString_FromString (pv->pv_attr));
  PyDict_SetItemString (dict, "pv_pe_count",
                        PyLong_FromLongLong (pv->pv_pe_count));
  PyDict_SetItemString (dict, "pv_pe_alloc_count",
                        PyLong_FromLongLong (pv->pv_pe_alloc_count));
  PyDict_SetItemString (dict, "pv_tags",
                        PyString_FromString (pv->pv_tags));
  PyDict_SetItemString (dict, "pe_start",
                        PyLong_FromUnsignedLongLong (pv->pe_start));
  PyDict_SetItemString (dict, "pv_mda_count",
                        PyLong_FromLongLong (pv->pv_mda_count));
  PyDict_SetItemString (dict, "pv_mda_free",
                        PyLong_FromUnsignedLongLong (pv->pv_mda_free));
  return dict;
};

static PyObject *
put_lvm_pv_list (struct guestfs_lvm_pv_list *pvs)
{
  PyObject *list;
  int i;

  list = PyList_New (pvs->len);
  for (i = 0; i < pvs->len; ++i)
    PyList_SetItem (list, i, put_lvm_pv (&pvs->val[i]));
  return list;
};

static PyObject *
put_lvm_vg (struct guestfs_lvm_vg *vg)
{
  PyObject *dict;

  dict = PyDict_New ();
  PyDict_SetItemString (dict, "vg_name",
                        PyString_FromString (vg->vg_name));
  PyDict_SetItemString (dict, "vg_uuid",
                        PyString_FromStringAndSize (vg->vg_uuid, 32));
  PyDict_SetItemString (dict, "vg_fmt",
                        PyString_FromString (vg->vg_fmt));
  PyDict_SetItemString (dict, "vg_attr",
                        PyString_FromString (vg->vg_attr));
  PyDict_SetItemString (dict, "vg_size",
                        PyLong_FromUnsignedLongLong (vg->vg_size));
  PyDict_SetItemString (dict, "vg_free",
                        PyLong_FromUnsignedLongLong (vg->vg_free));
  PyDict_SetItemString (dict, "vg_sysid",
                        PyString_FromString (vg->vg_sysid));
  PyDict_SetItemString (dict, "vg_extent_size",
                        PyLong_FromUnsignedLongLong (vg->vg_extent_size));
  PyDict_SetItemString (dict, "vg_extent_count",
                        PyLong_FromLongLong (vg->vg_extent_count));
  PyDict_SetItemString (dict, "vg_free_count",
                        PyLong_FromLongLong (vg->vg_free_count));
  PyDict_SetItemString (dict, "max_lv",
                        PyLong_FromLongLong (vg->max_lv));
  PyDict_SetItemString (dict, "max_pv",
                        PyLong_FromLongLong (vg->max_pv));
  PyDict_SetItemString (dict, "pv_count",
                        PyLong_FromLongLong (vg->pv_count));
  PyDict_SetItemString (dict, "lv_count",
                        PyLong_FromLongLong (vg->lv_count));
  PyDict_SetItemString (dict, "snap_count",
                        PyLong_FromLongLong (vg->snap_count));
  PyDict_SetItemString (dict, "vg_seqno",
                        PyLong_FromLongLong (vg->vg_seqno));
  PyDict_SetItemString (dict, "vg_tags",
                        PyString_FromString (vg->vg_tags));
  PyDict_SetItemString (dict, "vg_mda_count",
                        PyLong_FromLongLong (vg->vg_mda_count));
  PyDict_SetItemString (dict, "vg_mda_free",
                        PyLong_FromUnsignedLongLong (vg->vg_mda_free));
  return dict;
};

static PyObject *
put_lvm_vg_list (struct guestfs_lvm_vg_list *vgs)
{
  PyObject *list;
  int i;

  list = PyList_New (vgs->len);
  for (i = 0; i < vgs->len; ++i)
    PyList_SetItem (list, i, put_lvm_vg (&vgs->val[i]));
  return list;
};

static PyObject *
put_lvm_lv (struct guestfs_lvm_lv *lv)
{
  PyObject *dict;

  dict = PyDict_New ();
  PyDict_SetItemString (dict, "lv_name",
                        PyString_FromString (lv->lv_name));
  PyDict_SetItemString (dict, "lv_uuid",
                        PyString_FromStringAndSize (lv->lv_uuid, 32));
  PyDict_SetItemString (dict, "lv_attr",
                        PyString_FromString (lv->lv_attr));
  PyDict_SetItemString (dict, "lv_major",
                        PyLong_FromLongLong (lv->lv_major));
  PyDict_SetItemString (dict, "lv_minor",
                        PyLong_FromLongLong (lv->lv_minor));
  PyDict_SetItemString (dict, "lv_kernel_major",
                        PyLong_FromLongLong (lv->lv_kernel_major));
  PyDict_SetItemString (dict, "lv_kernel_minor",
                        PyLong_FromLongLong (lv->lv_kernel_minor));
  PyDict_SetItemString (dict, "lv_size",
                        PyLong_FromUnsignedLongLong (lv->lv_size));
  PyDict_SetItemString (dict, "seg_count",
                        PyLong_FromLongLong (lv->seg_count));
  PyDict_SetItemString (dict, "origin",
                        PyString_FromString (lv->origin));
  if (lv->snap_percent >= 0)
    PyDict_SetItemString (dict, "snap_percent",
                          PyFloat_FromDouble ((double) lv->snap_percent));
  else {
    Py_INCREF (Py_None);
    PyDict_SetItemString (dict, "snap_percent", Py_None);  }
  if (lv->copy_percent >= 0)
    PyDict_SetItemString (dict, "copy_percent",
                          PyFloat_FromDouble ((double) lv->copy_percent));
  else {
    Py_INCREF (Py_None);
    PyDict_SetItemString (dict, "copy_percent", Py_None);  }
  PyDict_SetItemString (dict, "move_pv",
                        PyString_FromString (lv->move_pv));
  PyDict_SetItemString (dict, "lv_tags",
                        PyString_FromString (lv->lv_tags));
  PyDict_SetItemString (dict, "mirror_log",
                        PyString_FromString (lv->mirror_log));
  PyDict_SetItemString (dict, "modules",
                        PyString_FromString (lv->modules));
  return dict;
};

static PyObject *
put_lvm_lv_list (struct guestfs_lvm_lv_list *lvs)
{
  PyObject *list;
  int i;

  list = PyList_New (lvs->len);
  for (i = 0; i < lvs->len; ++i)
    PyList_SetItem (list, i, put_lvm_lv (&lvs->val[i]));
  return list;
};

static PyObject *
put_stat (struct guestfs_stat *stat)
{
  PyObject *dict;

  dict = PyDict_New ();
  PyDict_SetItemString (dict, "dev",
                        PyLong_FromLongLong (stat->dev));
  PyDict_SetItemString (dict, "ino",
                        PyLong_FromLongLong (stat->ino));
  PyDict_SetItemString (dict, "mode",
                        PyLong_FromLongLong (stat->mode));
  PyDict_SetItemString (dict, "nlink",
                        PyLong_FromLongLong (stat->nlink));
  PyDict_SetItemString (dict, "uid",
                        PyLong_FromLongLong (stat->uid));
  PyDict_SetItemString (dict, "gid",
                        PyLong_FromLongLong (stat->gid));
  PyDict_SetItemString (dict, "rdev",
                        PyLong_FromLongLong (stat->rdev));
  PyDict_SetItemString (dict, "size",
                        PyLong_FromLongLong (stat->size));
  PyDict_SetItemString (dict, "blksize",
                        PyLong_FromLongLong (stat->blksize));
  PyDict_SetItemString (dict, "blocks",
                        PyLong_FromLongLong (stat->blocks));
  PyDict_SetItemString (dict, "atime",
                        PyLong_FromLongLong (stat->atime));
  PyDict_SetItemString (dict, "mtime",
                        PyLong_FromLongLong (stat->mtime));
  PyDict_SetItemString (dict, "ctime",
                        PyLong_FromLongLong (stat->ctime));
  return dict;
};

static PyObject *
put_statvfs (struct guestfs_statvfs *statvfs)
{
  PyObject *dict;

  dict = PyDict_New ();
  PyDict_SetItemString (dict, "bsize",
                        PyLong_FromLongLong (statvfs->bsize));
  PyDict_SetItemString (dict, "frsize",
                        PyLong_FromLongLong (statvfs->frsize));
  PyDict_SetItemString (dict, "blocks",
                        PyLong_FromLongLong (statvfs->blocks));
  PyDict_SetItemString (dict, "bfree",
                        PyLong_FromLongLong (statvfs->bfree));
  PyDict_SetItemString (dict, "bavail",
                        PyLong_FromLongLong (statvfs->bavail));
  PyDict_SetItemString (dict, "files",
                        PyLong_FromLongLong (statvfs->files));
  PyDict_SetItemString (dict, "ffree",
                        PyLong_FromLongLong (statvfs->ffree));
  PyDict_SetItemString (dict, "favail",
                        PyLong_FromLongLong (statvfs->favail));
  PyDict_SetItemString (dict, "fsid",
                        PyLong_FromLongLong (statvfs->fsid));
  PyDict_SetItemString (dict, "flag",
                        PyLong_FromLongLong (statvfs->flag));
  PyDict_SetItemString (dict, "namemax",
                        PyLong_FromLongLong (statvfs->namemax));
  return dict;
};

static PyObject *
py_guestfs_test0 (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *str;
  const char *optstr;
  PyObject *py_strlist;
  const char **strlist;
  int b;
  int integer;
  const char *filein;
  const char *fileout;

  if (!PyArg_ParseTuple (args, (char *) "OszOiiss:guestfs_test0",
                         &py_g, &str, &optstr, &py_strlist, &b, &integer, &filein, &fileout))
    return NULL;
  g = get_handle (py_g);
  strlist = get_string_list (py_strlist);
  if (!strlist) return NULL;

  r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
  free (strlist);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_test0rint (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rint (g, val);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_test0rinterr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rinterr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rinterr (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_test0rint64 (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int64_t r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint64",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rint64 (g, val);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyLong_FromLongLong (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rint64err (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int64_t r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rint64err",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rint64err (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyLong_FromLongLong (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rbool (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rbool",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rbool (g, val);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_test0rboolerr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rboolerr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rboolerr (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_test0rconststring (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  const char *r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rconststring",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rconststring (g, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rconststringerr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  const char *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rconststringerr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rconststringerr (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rstring (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstring",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rstring (g, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    ����u������s����HR����Ӡ_E"`�3"����o$)���"r�oBžp�D�`�-Μt��"A�
��a��q�5l�’Ʋ���lHl<����c�zb���&{"_�m��9K'�&����g�]O��7��k/?�G��x�8j�DJNpc��m'�3L���9��V񸰢����˂�#�ɠ��ؕh� �.�Y���6"8ˊ�{-H�5��ڤ�Oc(��f�:1��uJ��Ct�ȟ�J��Ӂ��!��9,�t�D��$���G&�
Q;��-�fxǜ��&��5�x :���L��L@x(��)�	��F_Xf���w"��vm(86i��x4�9
9+B&
u���Tf�h!�2mۢ�����r����SA��Q|,��pC-���#7��N�^�Q/w"�Ih�ς��!�x��[)@ɿa}����v`
_��πY�9(���:��?cj�
d6�Ԗ:G�i2^��`уNim�,�(Qo�?��ܜ����>�GO0��70��?YQg���� �$�ܞHKM�u,�P�V|�v�K
�?����E(Y�?��5<�znM2���	��(���O)�O�T�E���'a�P7�RA/�ܿ;�����?E�T��bZR�'
����p�&��`"��mIs�����$l�Bӝ,P���XW(7�=@G�
��*�
bg۪�!�+T
�G��w�T��?[��g�y�j��@�
p��wr�T�����Q:<'��$B�O�R�Y1��b�E�]���C��/��Vs��δ�*����<۔��[J�QI��'���(�"_p
�P�#XR
|����$�b�ȧ�1�h�Q��_��1�����>�i>�)�g-�i<��ä1�p�˜\tx+����k�>�������'0��n�q<L�U
_}*��� �
k�9&
�����5}5|��X��{0���'�F?���Mj��3r���r�m�P¿�l�-1��zz��#�y���ޑ�3��Nre��b�Y����sq�R(YM�HC�,[?�
��[�)V|��!�OIՉ�d#�XVD=r�H��V~ ���h��)9�e5À�m�j<—d�J[z.���z�K3
bxA��,7�J��DI�t�LT/�kˊ�x�s�xۑi���K����J�����Bg�q�[��rp#O���c�돋��[[�B��-�T"w'�u�kC"$�?ı;�'b {|�������l�X3�=�sP��5�`�t��fFh�Bi�Q��?�{�RHǁ�FO�
p8O�Jw�]��_��>��X�&�k]����9-�ĺ�h5�L*k`�mB��� �'=^.8Y�ɻ��a
�0
����Ї.�0�~�~Hq�E9?& ���(R�+S//B��t��WM�Y
|�-�,Ӝ��
�3�L�~��>Y�$���4/��X5'�_0���F
�F���SKz�((��M<���3���v����N; 8
tS���U�1Nj�ݚ�D�o�g1���>
�6���.\&�y��	A(NW�8 �‡�U�0_aN/;ϺsO7�
���
k(:�SB����U*��O�Q>e��D�����&#������^��η0�7�:�%�������fn&<��
t���N��o�i��N	����A���{�h��w�I�Ƌ�{��7����ʂ�Ô�S��x��m\��F��aJ'��wn�4��2&�˺�+��m��ErN����mP�F��e��!سj��{^�
�:�9���$������ţza��
"�Ø7��v�W�-�hyzT��&�*�a�;F��qW��ߛ�u�+��=�iL�GĪF}U�`���ٙ��L�rcQ�Tj]	�A�[i�DZ���4s.{�Yp����(\�yd��AZB����4�A�����jǧ�1f��"h�TT/z+��S�O�W~LW���>���hv��,Vp��w����@��,\{B5�Z&X�o�8�	
��� ��4G�=�W�'�7yt%N��g�
��4[B�{��
�x��}�j����K
����8�.��]`=���Yp�ͦ%ցv.����m?k+1�,PS��Z^,�_�wf�:�	Z��"A҈�G03s�g�
�S�o�
ϠN�
�]�/�x�}L`���*=�u��������	��+cg����J��/z4�ȇ7�����m��d���=����{+b�ݞ�
��#aB涹|�
@A�췽f�݉5W/�}���i����Kd��%^�NjX��4���8P�� �Wd����0���y�_���m�
�M��5����T�\�A���o/�E����h�#p�P`h4�k�L�͂���o���Hz�Gn"������˕�/,��bh��\�
�$;
�H� ����¼��E��\�%�g��/���C<�����~��[�H;���%�>�!9Q��~_��Va�^b���G��7���X��b�ߧ����%���ܦ�7����h^�,ѩ�=��U��.Q{%d�=)@��mr�6 ���޵O7A��&���W4�}ӓ)T��]�k�
|�.u+�+�<�>��MfHVG�����W
�/,�E�2�ڥiZ8g[4�;�c:4+��GY��-1d���Ig�� �j�.
" ,OL�<�W"_�<��ڥ�p�Q[6���I���a��ʴ�W���
���b9�-�t�Z��dn3E
�X��͙��e.�u�&SG����I�L�|LB��L��?8����[u�Sy�9eͭ��q=�a��|r3�끺���Rt"Z�.�}�x\,�Uqs���_�_��Mg��e���L�qM���똱���<�qҰ9$�h����H���"�
���:����wc(G<2|j ��҉�]#���۞�D��k�j�oB�|��.2���I�Q���M����쾙z��ƵgG�:)�Xt���Fg'�y+
H0F>q`y�AM���s�����pW/,�ߤ�<�A�!�MT�Ԝ�K8��LW�
�oc5�9�����]�0�D��T�Cp��41~i���It�o0�D~��c��V��߿��'\����$��ON�ɱ���>!vh�
���z���Jf�g��}�
��lµh�VYV(�����#9��ī?�F0�k�c�9d�T��.�`~#�04z�H(�v�	����h�St��qy��}��;_�5�3�@ѬF�x#�I>5^-h�l��������&<��h�9�J�sdC��n�0I
B��Zc�w:X��֡�lrW��Y,�g�7�@at�?���\1���P�2pܑ=��c<��72�{A�����P�VE��b���꺿Y��A�4�'V[�"�\p���HW�c�,)��D�כ��>Dƈc��&�^	�(I��ND!��ɻm���[��X�3q�w�Ӄ��@�N1��_�$����ٳW���V���ZW�x�;�|�d@=�~/V `��_Fsn��
!�:�躠X�e]Ȁ߯J�yayc'ö|��E�5Dl�Hkґe���#5�C([���7����{����c��@�=hG������p;
��<�������L��0ط碫@nжMgD���`m���k�O�bz
�=�,�|�a��/ ��HsQ"<�
��)Nɦ9���S��|2T�� �LӴ��C|9�+��&c�e�����7F�l�3�P���UT�����ǠX\
�&�(!9��D7Ե�s�Y�hc�.���m�O�7�}���oSsG�e�5�[�9G�]�%)2��`�_R�P�!�x�x��%��3�H
����Abe�M�Q��f��z�	�!2ڑ`�7�"8&�����K�;=jɐԝF�d[��N&����n�R��=���)(O'_������e0�
04jV$���
E�]��4��`�L��^n���>p�Q5�Nn��览�Mn�6���f�*L������wYݚ��[����hkb>"x�`��e���:��D+'#Vmf?{
 �M0�D��t���a�!���xp֤���(�R5�����*��(�`
t�,U��"Ԫ\uR�q_�?n�|�W;�d���j��i�������t:Ks78��2E�m���J��3W�x�	͍gks���;����g^Q�j����,�# -gqJ�ݘ� &��x&{�ޱ�ޒ���F�h��e�i
-�X�0�c~���ܸ�<���&j9�͕U��f�0������V]�y6�v�������?�PJu�3+rШ�X��&��o�~�m�i_	��W�xK�b{�|/ί�<��]ҡc�~���)8>�)�2��D��m��:֔��T�����魆�<��m��;=5�k��v���e�3��apu�I��P��v���s:����F����ה|�4P`	�̶�������G�}� �f�q'��¥�q��7��Z�S���B�1��w�"�ԄoV�V%R�P�Lf+��6K�����ϼCH�ʚj�n����tع����?E��	kP^������P�cL���z�l��l}�'�'�a����7�
��Ht�+Kx���W4 \7��
aXM�Z	�/0x�����b��{��[qceZ��|��x�O�fN��/g�r��Z��Ԉ�,�Gn�VJ���Һ`s���e<�nB�i?
�ڏ�2�Z0߃
F���U��F����w��|{���q�
+���A:�������cT*��_T�$N_�
��'(ȶ<���"d�|�=3f�EB^[��C�|�o�mJ��X��w���%̌}ژ���2-��	�������M?��^��i���0��`�bKT��\��0���.�B�&��G5�ĠY
^���D$Τ�W�u����k~�/e��謮tccl�
�U<NXq�G�yW��{I��t��Nm��1>��|��"�qf�����ctz�M���[I�b8��`�̅7��)�6�H��]O�nV��T,@��_���-��z��z��YH� ����B	^��O�|��#���^g&
�/�NE�/����&
	*��5O���ܩ8����>�}���y�5�e�a$J��a�Qo��/)0�s;|:v�I+��v�5�]~õN4�I5��!�
lD����)�W 4�<�w�8%U�J��,��v�*�[�&j/�7����Zz�˦��3�o��1e��ɳ��,F��f\u�P&�G�q1��~7
cX�a@EIl,v�1r������cȒ���1n�ԟ;ѓ�W��<�05ن��#�A��0�	2Hp��\�Lk�{Meq�)uӓ�0���"�[��oNF��&#��������#�;��t!�|����!����}�Eg��+.�F��]l��U�ToT�g��HR�j/��3��̡F7U�3W�m/)�8�DN���a$��A��k�	S!љ�Y���D��$�nEIc�RW�6c�\��L����
	Q�\>t���
ڮ�
�84��mJ\���!1���Rm��7��F�j[8]��Q;D'Cl�HT��g�?䆬�:��f+C�c�5Z5A?`1�*��a0����}E�������',�Q�+��s8���,���z���Ov�����m|�X�j ��WɗB�u.����_B�GG��JiKØ�E;I��m@�� 4ڨ�n��$���d�L�����G���\��B�=�H1�k�L��6
8���l��T99�F��1Z�,��:��8�3���1��4�8��H`He��#�b������L���a�U$^Kӊ~��h2+[�N�1��8���Q��N̅G
����ۢaj���I����	��|���$�
F���zgG��E����ͱȷ��옎8�&z��w��
1;�Ђ������|'K�J�V�ynZ$�[��\�А/syPͫZn~�/{C����.���C��.���IH�7}+���3|wQ �Is��!Vf�@��� ����b�P֐�m�р��|L�
���2R��F���V�`�;���t4��ԓ��M�2͊>��e" �[r���bb-XVVl��x�r��.�'@Z�ؓ�i��Z|D���,͓
8���\@��ĭ� �9��ԯ�ҞcR�Z�えs��&���p��琥��� O�0�?��Ц�1��-�����T����t;⼇5sO�-��Zk���.�<$��~fmY��,"����H�>+eK:u2g8�$�/���+���	���ߞ�3w��/��*"�R{s𧉱�`s�:�:�wb}�h>ȫyB�,�I��'�N?CI=5^�V��P�󉇅�Œ��p�ܕT
���q����?R"��ۻ�v��#��*f�/N����z=�X�|ܶ�U]�P$�G��t�}�
8G(`��0m��S�p��7��}f���"�h'�:/��u޳R4g�$=So~Uq[s��ӌ.IcZ�V
ƣВ��j����bw{���ǝsx��k��
P�TS�)��I�Z�A�NFiMI�T��N�����3�Lo���m���h�X�v\᪍FlK��Dc�KX�'[
��������O�������7(sQ�rk4�9���Ł��H&���D��z����3� �(��v�^,d���՘=)�;�6o�|�W
����?%W�$2�X���s~�N/���j��c��롍&o[�Zφp�.�V������nQ�m�OyJMo���my�4E����I'aUgIP�����e�K���tՌ��<
���o ��MŗZ��{N_�-�s$N�G;�O#{�@4�>�E,�um�ȺǞ
Yf�`n��ԋ�fve_�O����ou��������e	�U7Q|�@'�at�b>���_��K�š�j�O:�@�a�:����x��HW�i=�O_����|�������G�D�(%�R.ON@O/rQ�!�̥��L��%�;��d:U
�mz����+��;\��^̈+����؜�z+
ͥIÂoL��} ��67wYz�J�5�mZpѳX0v|����	�K
$�B&�����I��i�^x�ش�D�u(^�e��+ǚU'j�
�&f����N �O��#jӊT#^W��)��0<��4c�,���4�[r���kDOP�_�EU>�a ��}?T>V��DiB�Y)y�f�0i�La��͗�_]K=ý		̝�Tț�L�О*{q�^j�3�i��ڢp���3�o�d~�؀g�r���N:�*�|�
[���d::tA*&@Em4J<��SP.�~*ya�{L�/��F��:��t���`M�v�Icjq9�dmb���-�B�M2�ʎ	JJ�����	�aŽ��=B�̋���T~l�f������۽�D��,�f�(�^;Ԝ�'��6VQ��B��PỖ%(h<�܇,�}��/v�e�L�c��T�:�lh�s<C,�Z��
GHp�\�63I��go�a=�x��L�k\�fM�8{Vcab�6>���@��J�������۠w�(�`����:��-Q�"i��!��Oh~��7[�i
jB�d`ɖ�t�'+`�߹�{�#��XN^"�0�Gt^�%�3-�Ҁ�ͮ<�A��C����f�vm�)qY�
h���ך6���tjS<
X^��]!U���(OtF��� c_�z��_�D����t�Î�9�p��o��W[ٍ@�|D�<$�Hb��x���,�K�zR@�%�I��!�r7��4�i�����vY�c
yf�ɓ��PvVU��};�;��<��ч=$�3Ⱦ=��A��K�$|��k^��\�Q�xJ���m
�_7���+
%Q�u��|�t$RU�+Y/�b�aRO�}���k���S�mkx�O�c��D��2ۛ)!o��L��ݲ
&�#6�p�\�
�HyR1�n%����O
��i������@�3�M#I����*��{�pr������ȳ���0 ��7'��
%5�W&���k(]��b+ޙ>�j63ac��-�%��6bI��~�\��*��/�q���5�#�ɨ؊!
��e
Q�#n�'F���6G�728�'��ͻB#�v{��7\���3aMS��	���7�|�\�lC���
mlO# C�W�Zt��%۽Q�~�J��ǻ�	�B���v��0#�.�j|�)t	,�>���?�N�G�R��6��pNL�;z�A=Q�Rm���j�&M��K����%"�Q��_d6ë���A�wy
���ae�:1�=���>����u��J���,߀_Tu�6�5R�mU��̪��=TT��_�x>>�J	�{
Km�.��*��k\�A��nv!@ݭ=ͽ�NJ�=�f:0�)	y��_za�q�@���J	
0ψ��^�18kW�^�;"��©��e��.”`�{�3�.M�@bx1KЕڣD�@���'��ҭN���n�'�Cb����ӭ+t��.W��7�k���d���yt�[��T���/�b���1��-$�Ŏ��mM&Hm����˗H��&��.�5i�#�`��6oǮ|Y[w�2G|�T%f'b���ˬV���V��9@��L��UQ8�X�=K
�/�ےx�
��h.\~͂�gYW���,���Q+k2�3wsZ�d�vA�����^8�90n��<�����0vx��3GE��c8�H
����H�e�M`�@���׀��c6h{ԏӰ��$"�[�)s���ޤ�e�􌥙�^L���w�o	�Ć���YY[Ao����|U�_*e��s�LV��77�d���
���W����+��?2w���}aB}�͍I�;�Ma�
/��c�_��Fx��y��wĭ1�۲~t�����Ѭ�Z��XR�q��g(��z�̒MǪI�YTm��Ȼ�ֽ߻k�
�T�9���{(�op}F<�)\fY�c�S���%��
ű�}�#��`�N7D��5��3Q*����M�r�$�*O�$�E��Ԅ&������n��� i�'������
c�=����L��η�Bq�8�9�
:�M����=u�C3�!"S~��g��P"�,���e�c��'�V�b���u�^L��� �_	F�y�e��y0D��/��d5�VT�r�f�o9�iZze��a
«�>�%�3��Nm�s
�z6U�_C���=�cъ�쁙�hT2�!#@ �Vu&F�[̸��#1K��Z�=h^�9n���Eڃ��6*�O�.��#%LO"}�J�ɺ�pmQw�κ=��#��C{un$@\+a�gl�v���oM��E��%nd6�FO��e\J�m"Sn\C32�~M@k��Μ����d�Ln��^1߇�|Y��/'�Q�%�	8�I�>ܷ�8�
J
���]��S���ȝ��f
c*�?\ћ�O�:{P�F��B>��1=���'�_�2|�+`���{N<�Fl/�U?��#l�S�dFՁB0ƣ�YvxX<H:�>�m3��;s�c��eM�P�}���ֵy���,K�����Vk�^���(�^TeL�����%��Qu��SU�y�J��Ց�6���L�>�l��
	�:���6��䚿p6�v���rk���Ūy�&�zW?U��q��N�YӾ�jY�`7��C2�xBX�����t+{g��
���Za�FSh9I�md�	����)$o��?V��m�jO�����[�����5�p�"
�MC�w��+��=G�Z���s:��k���W�M�&�)t��f�ZOH�_��^T���3�rF9�?l���+�������eKn�u��">���NF��Ժ��iI��6J�͇��T�~�0Z�#h���*`���Ѵ����?I�j��zrNO�[�Fŵ��2)=\]a�7V��[��"�`�(�x>��󶏀�V��xgAn�s�[�߿u�I�$
�	�$�Z���5L�|ȅ^�%w��*pO�_��'��W���U>��w����Ly	S@#n� ��q2��3gو 識��#?�M�'�s^�ѹa��=�Ө;+��_#���_������5�T�W�Ǡ!J�&o�G'����h��)�=`�
1�dT�s�]�Y���P��a�a�I���Ŕ��lobA�_;6��O�ӿ����
T�S�:y��XF�ޚ\�8�e�ۭ���Y�����ˁ�����������*-��d-
)�A�
Úd�#���&��p{f�����6Aw��((>U?�-R��,p����֭~/mU�M�Bu�{��j&)MQU���4eq/)M]x[e�\�
�-j�g�3yŌ���X�+�V��_��tG���[�=�u�@ү���0q��o��r3���km���A�g5D��S�mb]��p_��@1.{�	R�n��I��Pc���e}:����@2C��!ҹMYβX�Y���!��Tr�g��ȥ�ə�g��f�B�a���8�]τ���$�Z�L��V�����m��
�j����z+��`9&� �GCU9���J�1�ի����]�A�|HR+��xI̭�q�����2��0]�{Ue8�s�?D�#:��֚��&�,_��ħ�O`?��OX3��CbIr�C��~l+��>�XM��0R�ZvsO��z�Ǧ�OS
�G����Q�ݯ3��Q6���-����o4�cǜ����E�]�՜A.�[
1
���L$�仇���3<t��u������
����ge��m��B��I���b7 ��
1
��ߛ��W�>���j%�}$�3��c�P��<�Ѧ���^�̼�k�����N�L���a�!<�(��l7��oS~�j�vi���I�pb��[�5���KuIP\Q����p�ݶp����3�<3����x�o��T<�p21�}�:�+����e2$��&F
z��?�nkw\}>��U=8g|(Jd�!�z�]�C�Ȇ��zge�7��r1�4GWh�42�F��<W\���q숣rMV��$tm������"l�)Cp�����^6�g�A-��*c
�"�|�[�_k9ߐJl.҈^�!��œ(l���Nӧ
t�I�A 	J�7�,CTw��l�wD2��6�Zt�4��h���
��7DH�W�4�
�Dx0�k|�#��&���u�G�>E/�ܣm��^(Ρ;"�p��?rc��g
���(P�:;�����z�K�&��]��^�ѹ���+���O��¨�2@q.��l�����;�����Y�x�|=\3{�5�m��\����2_	�0�i��+O��e��1@n��k�^}ˁ0�Fz�L��	{�����.~�����"Ww@e��7����A
9L00��%�{����Qr`Ukߴn
j�7ֶ$1Z��r_�f{��0������^�
�
ߎ��9�K�Y�����KXN�<$��@�?�Ϩ{b%�s���������3t$*��C��VIUǾ璬�s�4�n!L=9t6-MC%aBc���
��)�����{�+K)�kb�*�H����v"󟕒��Y<�k�94^�7�@I�'�a�l�y��݌�0���&ncr�����x~"G<[LSkG�����
и�W���'���`���qx߉�b�@�r}�#N�~A�+L���c,4~���<�tӆE}�����i�Ԃ�>�Res��66FF-����V·
���.��夬W$�r��W,���!�[fP.S0=�cnN���F �N�:t�-\��׽�l��F�7rb�@6��%}:�����WT�xÌ[�g�|f}�
ỻ.|�y�}���],�-�8��q?59����2���{:����[�F��b�_��U=�*5�J��yM�S�t�� �|��i~Ty��:;�����caR����7�����s����|�d��Y��Z��|�ߒ��]�{ئ�׉a��#=-%������	�5e���|a��Ҹ_z���<��E�P�3X�+>����ڞ�30�ʀ�z7}���j��>��:�5.#C1�Of��0��[���م�Z����Q�>�'�BTŵ�݌Y� 8g�>׼0R�V��ae��4S-(ءS��r��Z��췙�.�wc�����
��g�F�D}�%�����`uܵ}lk���JBŔz,&7U�
"&�*h�;VX�9�h��n�H��!�_=q]�U�[�j��
xB� ��
��V?�ڕ��|�\{���i}0{²�C����F�<���\6�J��'�(�\N!�X�;S�f~L��蓊':"j^��~�Z��EM#���@���[���+΢N�z�_��t��׸-xdzA�b�ߟ��aDZ��Pٚ�
k�-Ϲe)dÊ����i��s-�L!�	3p�]�{$�-f.J3�O(�tx:έp��L0�=@\e�M���5��}%U&l�ٳ"�[L�@��JLwR2�,iGl�MYpJS�h<:$�!�V�v��]�%��NA�C{��[�=��ޠz�eV���Q,9���/��&y��D8�l?�	��l1γ�(����Yx'ե5�}�f�i�N���|���d���h2‹����m����=��䬯Dn#{U��(j��k�"�ܳ$�8M3�w���D����ʗ9�a�&g��Qeƕ���z�FZl���og� 
����A7���]�G�a
kje;���w�bv��1�t/j�֠���tI�@���Va{	*�낮n�����$�ׂ�1u`�An�}I�$<�a��xIOY���J�gZ�d�F1��Z��:������n@K;Y��`����,�
�-�$"��=�Μ�S@c�E����=�z�-A���!�m��)���)[���k��hu=��О��g�J'�{e'�`CE�sl�
�s%T�r�����%Lb�DK!\�v�Mks��(vW#H㖚ڢ���1qV('��D�l<�q�����E���K%c�������\�=�vF���Ucl
uAB���Z��~��X/1Yz��A�%N,�F(C��7]ЩxQ&/RzV�(�#.�H�n�%�YC͠J�A��f�vEd����&�����i�
V���Zp*����Ι��>�%��6Ğ�
�_}2q��u�	�;J�IQ���aTXF����$�_�ܒ�����(�<����[���2)o�9�*#3e��%�u�4-�dt5��"��꘢z&��ņ蚾>p������1Q��̾��*p�,�
��=P)�{��
Ÿ�&p��&J���Cn��j}�4��Y�1����-��sA�V�
�B�'��cKE*����!BIG�� 4G9|�=����އˋ3T��%x9�}K��<�1�"U�	[�a뻽srG��Aa�2���!릕��٧i�]����{7��'~`��o�#�2���MD1\(Lc�v���e����.D�����c���[]:��L��_%�L�.o���p?_H�a-rA!�7�3��ӋG�hL�w|�[N,![ɥ�J
O1(��ʌ	V��l�-���|�q"}I�=H6S�!d�jZH��W�V�)��I�(�{ö��{���(̱���,���8v�#f�������T*j�ٯ	x��̖��V��ߖ4��t�]f�2l|���a�H�[�ĸ����
��*�	;džs�0��RH7ZQ8dƼ,����zD�L�"��"�䏹���n$��,�쬇Ǥ����m�������sބ+���V|R��:bUv�@��Pi�#�Öz�S���av5�DhK�o�W�)�0gG۽ԇ��p�jE�p/����l�c�����&¼֗[��]n�����]������|&��W�u��g��6z��kusU��c��
��_�F��7�~��;E��
Pݮ�����'C�*Q�?qN׹�n_Q�	�M��gJ��4E{�E4�2�j�C~�������%���%�V(��0��jXiy"�V|���Ff�閰�`�#-'��D8�ٳ��El���q#��	-��^��=Dwb����)��AN���:���R ����B�)'t֠4Sf��TJ���]ڮ�ِ��R�ru�����(�	`�Me��a��vķ�Ҁf�0�E����4q�܅��4�=,��;\����>���
~�}���'��<̻
���mj���E��QI)c	?}��PU��װۚ�j\�k���ݤ-|�\��=�u���FN���K�_�`�%��
^t�ޥ.�%�C�H8,YZ��n~��;u}#�_���Ƴ��C�M���Y��z�ӧs9R���P�t5��QJ;��D�,���}5GB^���X�b(��}��@1�l�c�<"�ڔ�Z�n#���1�|�+?�Rޝ0�eu�GE�/�����)~�m!Gl��z�Hݰ5�e_>
x��	�z�ӓ��0�J�o�̳�W���Tu�`�εx�Ow��_��~
������Y!T�v�Iӹ��a�->�Q��{�v��)#�:�՗���Ê&fh+��̷P���D�cA���^,O�%�L$v&oI͎3�;(�o����NV�"��O�)�=EJ��K�	���˵y���@	_~q4g�J� �+��z
��thx��)t�����^M�&y����竁fj��	](�[I�|��QX*Zj0ђM6���;~
���IP���Ӫ�c�S��X;ke䁜U��w
z<����S(�%�:�0@sJ.M�ŝȾ����3��K��6��A�z�'�;��a���Y\s��)��Rd��Bǘ��~q�0� ���.���E���рޠÿbx�	��Ȯ���^|�E��G��3jU�k:�Ӟ9��^x2��6S�l�t�}����b������,یh:�͡��A�'£�7�,����h�����qe�SXr��K�q@�̑�:���Ư1���)��6��C�A=S����m�06��}QL�h)¨�W�!�77���?��ˊE�|7�A����KGYOi�Ȫ.����>��5]I�!��&ᩗ��(�B��ӳ�,��3�ӥ��*�YHCڥ�:��R�A�o	�n.�7�՚�XN�c�p4c���������tUv��(
����o؀P�	g�z���8S��)�^^<���v���)<���-6�s�*֭��U8�_���5���?�RA�H����	�H��˃+��:YAWj�R�{�״ˮ��ON�%g%�" )3~n��l���I�ՃD1�1[�s*Y;��l^���)إv�T�X��U���Q��g����O��c��2��Ps�Z��?\ڀ_f4��9lR��] ���A-x�O�����P>�)��?���R{�K��5��R�{F.����*-2c�)X
@;�q�ּ�B�
'|�?k�
�u�zap{���\�z��3���[���.(51��y����GF(��$M�
(3Uh��-)�K7xn���
*jf��չ�@X���W���%���V$iŵ&�X�Tq��d�&�聱��W��y|��l�Q�f��Eh�F�{�0<�N�ֽ�
��b0�չn�7-!�<�Cݵ_��y�����:�0����7�'e�����e���x~�2:Y��c��;����IA/�Bt‚T������F0�A�B�tB��́�����02�fy�������c���l�����~@��1��i��V�hQ��GDԔ%ehdt��d�"6J�>�v*�u��Ɣ�6 R��K������v(��%Ĉ6J��][�T��9w��e��l[�u���J�4 9>��8�\������x�'+�Hy6�6�1s^R�y��7;1���J�<c��~U���?��;�L�v�
�������]��5=��j����g��7��\�N������Sv
RZ��M�򩮫>���9O���E�3���r�3�X��YZ�>�5�~�]�v�'�u9O�����h4�,3�����॒G��א�ZS�.��g��̗�:�2xo텟�����T�
�����ߨ]Q����2v%�s|L�ƿϿ�=��&t�k��.�7�b��AU5HB �^��H��E�;�*ٝ)�D�[;��9�R�_j��n�Çu���8�`G�N4����C�^�~�.������|��X�8�vMt�])�%��
����ɏ���[¥c��*+����y�8	j��$�yWϷ��:�rVG٧�,�b��@���j���G@b�]v����"?��77���K��/}��|B������ea��h�ݒa���:EnJ��V�`�5���j�':��Bd-�c��b
�7�M�a�og�����u�2��]c۾xx3�P�Ec�U^���	k��_o�_�S%^Q�'Q����,�AI7�
;
�A��Ar�>��,�đ0��3R��\Z��Ƥ�
�o�V���-QkX�\�wɷ���>��"���_��+ހX1�Hf��v9Ӳ���o�$�@��`�.��r��WG9�hj��nFt������J�N����o�� �Q�Cl�vt��]R|e��1�;���F����W"�3�Jؕas���tO��խ���<�K6�=��A����	��٦�����`Ώ��ij�3Ε巠)��>"� �Q����{�̶���z��-���a�c���*f�P�
����'ۨ)�f���br����dy�u�R��x
��5�D:����m&���+~�&U�^����+e���ߘ��e�V�f�e�f���R4�����[�+�o��<�t�z:/Q"��x̧S��d	�H!�
��5ʷ�ڜ@���Gj�ܿ�=DI�O��Me��_c!%�'�������!y�H���AR�|�����4�`���:zL���/�nBF�����Q��T��B���Z�3L���\C�ܵ�]�a��#��
=�<�07L@%��@���	�~[��P��
����YO������D��|��E#�P@�L�_���wC��E��Eݍ�fjZ7��G�ӄ�f9M�!����ې�#��]B�E�d+�1�M��^%1
�����tf��nn��\"�!���(a�%���Iŧ$�;K�HIٟ�Id��<������ĸ��ؾ?m��c=i���n2�R�J�����B}������1��:ֲhn+��S:n�4��)�3T0�	
p�Ť�	᧵�'���툊��eg�Np���K��%��/h\��;ۑ^/��=E=^��H��c9�h�t��6+U�U8X}#G%�
��Qʴ�>q���@���`t@�������Is���g�g�t/�%����>�4:�QX������Y��[�-Y��5�п��5Շ��廆��-�#[���D�s�7�����h'�j�切8�Ɲ�|���(�9�t&��ě���`J�������l)M�RT.I�d�_W�9��K�-/��H���$Z-����93K҄����pxB��t��5�F��„e�	,���n��l;��O���
.<��e�����FÁ�0�.�C��O��x���Y.�R�m�a`mu�/�΍Y��g>d^ޙ+!�L<t-@�{��ɹ
��p�E@�<��_�h3Ý�cx����P����]/a2Qw"v�Y����h#ε"�DF� �b�������~��ӊ�d`%�+��0�Y��*�^�c˱y���,��S�(Wg�!��r������e,��%�AI�iz罟p�
!}��Rx<�2̥knj��vݥY���au��#,u
|~��Q�b:q��
m�㡚�ko�������1�yS<�td>ٯS恢?\Ba��Rr��'���6�i�?���CÍ�Қ�b�έ���pO��zY�
�~�l�#�d��f׉SFԴZ)����j�1Ka��EZB�
�����D�w]Q��v��O��6g�3<�����z��TAp���#Ùh[@ڊ�&rv�ZB�4�f�
�4��������%�ڪ��l�}E�Z=r��౱S(��@���b�sQ:N�b����^�����&���NQ���&ʹHa��ɼ�ݷs������(Ҧ��f��ht���V�{��52�5z헯�"���b�u2T�%�ڛ�I-��F[j�$ڨ������ż`r-�2K@��(�8�
9*��щ�'&��
v�$�)�d4xWG���7��+	:���rBV��P��bM�J��ǥπ a��zu7�nO��9G�h��*'�$�w9�|�8��#��Vs�2�7y>�ug���W������(���<`u�v\q��9�}pPL��#���ɫZ����2�
�}�-�_
n�O@֚�JքGW�‰�YN"�
�
���v���|�
��R1ҩ�����()I����9���"�L$1�T+i9s���0쉂�O��yH�m.цu�.BB�'�G�fkÝx�j�0�u�[��2�� aH�ҙ�scl\u���L6I8#qi��6��@*�h�8/���G�9��f�|�����&哓�r����yk���r�d���4r(�9�>��V���ׂ��U�'�U���'x�x{h����sY���F� ��j5ˊ��(`/y��.iIn��	7oO2�����J
4�������c��K�[C_3�^�
hpw�f&��/ط+O�䒢��C�|6
�u(��Aj�D�:���X1��F����f������Ͱ׼��C�
��i�8[ݰ��W4��%��ZR^�𕟍����z��o�\��"��虮���n�8i�h�g�l�c؝��_�7�aE�Q��j�$(�clu[�h^�Q�3�W3��.���?(<��i:A�1E\��ۇ.w���#�����}�͵�){�J�O�RIS�$}�--@�/x�l�R�O�W��_~c���=nu��\p��ٕc�&؝7�6�8xk^m�/w��&��
�/wy��E�ᇏi�#�+�Af�/��X�U�H�ގ-&XG���d��
K�E.�D�%S|my��3���s�B�@�Ơ��x
��,�Rg� & i�����!�=���3��rd�������R�-_���ї��r���	���_����_�H'n`W�U֠��3s��Į:Q�{�dR����.�hӂ��Rd�à�?w7�r��V|5Q�r]���܆�
}H����h:��P������#���Z��p��r�����vĎ�C�����y41vE��~̪҇<��$��S�
��2!}
�0�7�?��`Ç�+�t $��Ʋ~��ʠٽY�
�c�9�lA��
�;�SjPd�7n���Aߞc�@(C�o��W�mMpGJ�m�-ҟ��W����X���M��H 	k�R�
r�*�Rb�m*�7��:��Yz�Z�^����3J>�g'�0x8���znEƆm5�).6�.0�`^�o̼�թ�B��)EU*Aϱ�\l�⢓����x�.ǹ�mg,����8]�
��;Տ
�z��&,�2W�g�7Q��2��� G�s()8�}���<�ܪ�.�NP��Pj��?M�$����j+�,;����(��).�����|ߕ 3\i��$t.f.l(�p§}�=�H�P����'�U��
T�ʰ
�TD¬�*pM�.C�ES��?�i��O���
�L�u���M���l;ԅ�U�g3hT� Iƽ1��e��<����os�r�~h�R7�7T�7T,mЍ�4R�Hk(rt���p]�輿�4��%p�q�_<>XB`�fXt��y�M�F�E䊔��-Py�I>)�`�5ӕo������^�S$�|W&-X&�o�̗��dW��w�^3��?�+�feo
�rdȽrՈ�~-��b�#��/��9ի,|J:���#�5���Ϋ_kW%&�W���k=r���fǧ9y����y"��~2�R�Q9^����l�q��"񐐌��hV#]���>"��r��L]7j��RK�,�������W��,���o˪��Ż����x3��4����z%���V8��
YL|3�# �|��@���.������f���b�i�P�sA@
����@����	����˧gR1����ʻ�̲=G�9\U�+C�n��I��p���<�5�7���u���[�Y���e����2��1��ӛ��^^GjI��y�y��)}���bj���gU;���5�������N�.'�B�{s�BI�*�_�x��9_l�;�#�p�@���Xfx��L9��GN0���C�)��P��H���KD��Xn�;�~B���v���=��߄$��&+�4`*w}f�w�P+s�h۪�J*�w��y�WZ�C<�췟�sUT��tR��"�3����	V� �I�K�q�ף�W�;D=���

�j��8���²m��+e!
+����͹+���̵"���4áZ�:��;T	����L"�T"����Ґ���Sr

q��cv����l��C˸��J��g��D�ᬱJ�*#�kep+9�{��
�Ou!L�Vq�Y�����Nҫq1�s_!t�%f��'
&PHLɘ/˘�%%ۇ)���4t�R+Z
$[5�G������&�l�F����c"8{~��g��d��n�Y����$x�-qN�F�v�p��|�T�D}�������h�B.�1H�
��g�1}:��|���,/F�J5�?A-
x�u�B����޻/b����#��.NA E���߅�>�{e]7|���7>J�_eϡ$*v=�zgIӜ?��c����d~���CR�c��5���'?��W��E!�⟂��8v�Sh2S��/$֞r����Y��j�.}�TX���UIs�^�A==�Q�Bx,H7�7�҉י�Kt^bh�C�i���s�*�8z6���%5�R��J�3�t�Uc�-=�.�
�eD�i2`��n�=��5/�؇"�y�&3�����x.�M?x�P���¥N�.�'/����L�~fMj�!!����њ�j>�7��$�9��,�����fb��uu�]�nI��T5n��s�|��L�V�p2e%t?;������gm�>;2�:g%Z/E�BMY�HCҸ���v���,�
��.��[(��BJ�*xuJcۛqÁ�q���E�� �x�X'��+w3�q�m�??��1�3�
4�:==�y�C^Qb�MtS�L��`��lk�}6��G��;�h�<�FRK0�_߆�K��ē��bˮ�� ���2���0XJ�G���"���c�ͨ�Ή&���R�$�tvҫ����{�Laz<+�_q���'�ϡw��@n�C`�2�,-: �hÖ�)ޝ8|������(I�������.k�`,�.;&�s���{��g��,�p���}헋Y�%0��7�_O���j�(�Ӳ4��뙉��|��^S�k��9p:�1�i�[�Kj�lT�£�s�_K���Ag��V��űo��,�4dp���~�pE���C�R�/�A%�u����;�(y�z�M/Mg��g�%��Y�O(���@q�i��-�$ƫSd�Q���.6�!�$$&�l�U=�����zqՆB��j��N�-d��u%�_(�����TC�F(P�c�&"�/�Ϧ!��j@Q[���|�8���yD!�HX&b\��G�h&�~�������.�|��U+lT�w?1o��;]���(�x�,�o;3�p���^P��z�46��1,
N�yd�9a��Vg�_�U�A�*6K>.H.]��2s��L�*�e�4�~�ZK��d�W$n��ç4���f�Yү��T6x��ڜ,B/hд��'�H���&�z�l�YV��J�iL6�eb{��s�ܠ��I��qC��:x2*�RZ�JmG��B;.?]I!&o���Q{��遡��Ot��(<"$�_H��U�U��'���g���5�YWj��%k+�
���!�u�C�R-���!��R���,dy���2�̚�)�$��f|�Z�n"7��,� i7�N�l��%�0J�݀A�7��TO
�啜�V�ذ��/8Z�Ψ�O��Xb�d6�n5����!ֶ{����*��@���h"�ɭT�؉�N0dSd!6�k�Z�{�|�@���i�U��S"�P�!wu�?�H��,j�W�����eJ[-;��g����Ǽ�\�ۖ�.Y�~�\���J��Km��V*6ވ~�n����G!��p�O&�����z�_�EwՕ|��$e+_L�4�pud�;�,
��N��.�$^��V���LQ�&.К/�z�X�æ?ޚA}0*�ձ���1�
��Ǖ%���$��PKǹVKX@vL�0`�~�hwT�4t
����ֽklѵ��e<(��1��ؖieA�m���p�_��ձ ��ɸ���5����)�9��u����	�
k�T�i6X����m
���Jh�}��mͪ�3�y�k�k	}�wf[��ن�
������ 	�a�Aف�>��4�Ća���K�2~/^2
#!�P5Uy�|��N9�R̚&���Aeu�yI�c��$@[���!���E��Z�9��7-�ݻ�ՕX���5�a�z�v��0�I�U�T���7��7ѕE�1�f��

  py_r = put_lvm_lv_list (r);
  guestfs_free_lvm_lv_list (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rstat (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_stat *r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstat",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rstat (g, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_stat (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rstaterr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_stat *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstaterr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rstaterr (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_stat (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rstatvfs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_statvfs *r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstatvfs",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rstatvfs (g, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_statvfs (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rstatvfserr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_statvfs *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstatvfserr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rstatvfserr (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_statvfs (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rhashtable (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rhashtable",
                         &py_g, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rhashtable (g, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_table (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_test0rhashtableerr (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rhashtableerr",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_test0rhashtableerr (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_table (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_launch (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_launch (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_wait_ready (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_wait_ready (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_kill_subprocess (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_add_drive (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *filename;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
                         &py_g, &filename))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_add_drive (g, filename);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_add_cdrom (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *filename;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
                         &py_g, &filename))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_add_cdrom (g, filename);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_add_drive_ro (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *filename;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive_ro",
                         &py_g, &filename))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_add_drive_ro (g, filename);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_config (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *qemuparam;
  const char *qemuvalue;

  if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
                         &py_g, &qemuparam, &qemuvalue))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_config (g, qemuparam, qemuvalue);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_set_qemu (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *qemu;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu",
                         &py_g, &qemu))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_qemu (g, qemu);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_qemu (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  const char *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_qemu",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_qemu (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  return py_r;
}

static PyObject *
py_guestfs_set_path (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_path (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_path (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  const char *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_path (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  return py_r;
}

static PyObject *
py_guestfs_set_append (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *append;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_append",
                         &py_g, &append))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_append (g, append);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_append (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  const char *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_append",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_append (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  return py_r;
}

static PyObject *
py_guestfs_set_autosync (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int autosync;

  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
                         &py_g, &autosync))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_autosync (g, autosync);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_autosync (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_autosync (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_set_verbose (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int verbose;

  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
                         &py_g, &verbose))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_verbose (g, verbose);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_verbose (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_verbose (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_ready (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_ready (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_config (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_config (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_launching (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_launching (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_busy (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_busy (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_get_state (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_state (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_set_busy (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_busy (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_set_ready (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_ready (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_end_busy (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_end_busy",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_end_busy (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mount (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  const char *mountpoint;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
                         &py_g, &device, &mountpoint))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mount (g, device, mountpoint);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_sync (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sync (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_touch (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_touch (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_cat (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_cat (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_ll (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *directory;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
                         &py_g, &directory))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_ll (g, directory);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_ls (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *directory;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
                         &py_g, &directory))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_ls (g, directory);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_list_devices (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_list_devices (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_list_partitions (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_list_partitions (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_pvs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_pvs (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_vgs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_vgs (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_lvs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvs (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_pvs_full (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_lvm_pv_list *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_pvs_full (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_lvm_pv_list (r);
  guestfs_free_lvm_pv_list (r);
  return py_r;
}

static PyObject *
py_guestfs_vgs_full (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_lvm_vg_list *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_vgs_full (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_lvm_vg_list (r);
  guestfs_free_lvm_vg_list (r);
  return py_r;
}

static PyObject *
py_guestfs_lvs_full (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_lvm_lv_list *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvs_full (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_lvm_lv_list (r);
  guestfs_free_lvm_lv_list (r);
  return py_r;
}

static PyObject *
py_guestfs_read_lines (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_read_lines (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_aug_init (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *root;
  int flags;

  if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
                         &py_g, &root, &flags))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_init (g, root, flags);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_close (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_close (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_defvar (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *name;
  const char *expr;

  if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
                         &py_g, &name, &expr))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_defvar (g, name, expr);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_aug_defnode (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_int_bool *r;
  const char *name;
  const char *expr;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
                         &py_g, &name, &expr, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_defnode (g, name, expr, val);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyTuple_New (2);
  PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
  PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
  guestfs_free_int_bool (r);
  return py_r;
}

static PyObject *
py_guestfs_aug_get (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_get (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_aug_set (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;
  const char *val;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
                         &py_g, &path, &val))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_set (g, path, val);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_insert (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;
  const char *label;
  int before;

  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
                         &py_g, &path, &label, &before))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_insert (g, path, label, before);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_rm (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_rm (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_aug_mv (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *src;
  const char *dest;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
                         &py_g, &src, &dest))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_mv (g, src, dest);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_match (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_match (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_aug_save (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_save (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_load (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_load (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_aug_ls (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_aug_ls (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_rm (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_rm (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_rmdir (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_rmdir (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_rm_rf (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_rm_rf (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mkdir (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mkdir (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mkdir_p (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mkdir_p (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_chmod (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int mode;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
                         &py_g, &mode, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_chmod (g, mode, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_chown (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int owner;
  int group;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
                         &py_g, &owner, &group, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_chown (g, owner, group, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_exists (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_exists (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_file (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_file (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_is_dir (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_is_dir (g, path);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_pvcreate (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_pvcreate (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_vgcreate (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *volgroup;
  PyObject *py_physvols;
  const char **physvols;

  if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
                         &py_g, &volgroup, &py_physvols))
    return NULL;
  g = get_handle (py_g);
  physvols = get_string_list (py_physvols);
  if (!physvols) return NULL;

  r = guestfs_vgcreate (g, volgroup, physvols);
  free (physvols);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_lvcreate (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *logvol;
  const char *volgroup;
  int mbytes;

  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
                         &py_g, &logvol, &volgroup, &mbytes))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mkfs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *fstype;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
                         &py_g, &fstype, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mkfs (g, fstype, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_sfdisk (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  int cyls;
  int heads;
  int sectors;
  PyObject *py_lines;
  const char **lines;

  if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
                         &py_g, &device, &cyls, &heads, &sectors, &py_lines))
    return NULL;
  g = get_handle (py_g);
  lines = get_string_list (py_lines);
  if (!lines) return NULL;

  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
  free (lines);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_write_file (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *path;
  const char *content;
  int size;

  if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
                         &py_g, &path, &content, &size))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_write_file (g, path, content, size);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_umount (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *pathordevice;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
                         &py_g, &pathordevice))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_umount (g, pathordevice);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mounts (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mounts (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_umount_all (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_umount_all (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvm_remove_all (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_file (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_file (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_command (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  PyObject *py_arguments;
  const char **arguments;

  if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
                         &py_g, &py_arguments))
    return NULL;
  g = get_handle (py_g);
  arguments = get_string_list (py_arguments);
  if (!arguments) return NULL;

  r = guestfs_command (g, arguments);
  free (arguments);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_command_lines (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  PyObject *py_arguments;
  const char **arguments;

  if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
                         &py_g, &py_arguments))
    return NULL;
  g = get_handle (py_g);
  arguments = get_string_list (py_arguments);
  if (!arguments) return NULL;

  r = guestfs_command_lines (g, arguments);
  free (arguments);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_stat (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_stat *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_stat (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_stat (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_lstat (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_stat *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lstat (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_stat (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_statvfs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  struct guestfs_statvfs *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_statvfs (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_statvfs (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_tune2fs_l (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_table (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_setro (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_setrw (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_getro (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_getss (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_getbsz (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  int blocksize;

  if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
                         &py_g, &device, &blocksize))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_setbsz (g, device, blocksize);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int64_t r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_getsz (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyLong_FromLongLong (r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int64_t r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_getsize64 (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyLong_FromLongLong (r);
  return py_r;
}

static PyObject *
py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_flushbufs (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_blockdev_rereadpt (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_upload (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *filename;
  const char *remotefilename;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
                         &py_g, &filename, &remotefilename))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_upload (g, filename, remotefilename);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_download (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *remotefilename;
  const char *filename;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
                         &py_g, &remotefilename, &filename))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_download (g, remotefilename, filename);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_checksum (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *csumtype;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
                         &py_g, &csumtype, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_checksum (g, csumtype, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_tar_in (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *tarfile;
  const char *directory;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
                         &py_g, &tarfile, &directory))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_tar_in (g, tarfile, directory);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_tar_out (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *directory;
  const char *tarfile;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
                         &py_g, &directory, &tarfile))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_tar_out (g, directory, tarfile);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_tgz_in (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *tarball;
  const char *directory;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
                         &py_g, &tarball, &directory))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_tgz_in (g, tarball, directory);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_tgz_out (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *directory;
  const char *tarball;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
                         &py_g, &directory, &tarball))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_tgz_out (g, directory, tarball);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mount_ro (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  const char *mountpoint;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
                         &py_g, &device, &mountpoint))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mount_ro (g, device, mountpoint);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mount_options (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *options;
  const char *device;
  const char *mountpoint;

  if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
                         &py_g, &options, &device, &mountpoint))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mount_options (g, options, device, mountpoint);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mount_vfs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *options;
  const char *vfstype;
  const char *device;
  const char *mountpoint;

  if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
                         &py_g, &options, &vfstype, &device, &mountpoint))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_debug (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *subcmd;
  PyObject *py_extraargs;
  const char **extraargs;

  if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
                         &py_g, &subcmd, &py_extraargs))
    return NULL;
  g = get_handle (py_g);
  extraargs = get_string_list (py_extraargs);
  if (!extraargs) return NULL;

  r = guestfs_debug (g, subcmd, extraargs);
  free (extraargs);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_lvremove (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvremove (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_vgremove (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *vgname;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
                         &py_g, &vgname))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_vgremove (g, vgname);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_pvremove (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_pvremove (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_set_e2label (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  const char *label;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
                         &py_g, &device, &label))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_e2label (g, device, label);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_e2label (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_e2label (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  const char *uuid;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
                         &py_g, &device, &uuid))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_set_e2uuid (g, device, uuid);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_get_e2uuid (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_fsck (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *fstype;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
                         &py_g, &fstype, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_fsck (g, fstype, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_zero (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_zero (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_grub_install (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *root;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
                         &py_g, &root, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_grub_install (g, root, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_cp (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *src;
  const char *dest;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
                         &py_g, &src, &dest))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_cp (g, src, dest);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_cp_a (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *src;
  const char *dest;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
                         &py_g, &src, &dest))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_cp_a (g, src, dest);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_mv (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *src;
  const char *dest;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
                         &py_g, &src, &dest))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_mv (g, src, dest);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_drop_caches (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int whattodrop;

  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
                         &py_g, &whattodrop))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_drop_caches (g, whattodrop);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_dmesg (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_dmesg (g);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_ping_daemon (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;

  if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon",
                         &py_g))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_ping_daemon (g);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_equal (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *file1;
  const char *file2;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal",
                         &py_g, &file1, &file2))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_equal (g, file1, file2);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyObject *
py_guestfs_strings (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_strings (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_strings_e (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *encoding;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e",
                         &py_g, &encoding, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_strings_e (g, encoding, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_hexdump (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *path;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump",
                         &py_g, &path))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_hexdump (g, path);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_zerofree (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zerofree",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_zerofree (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_pvresize (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_pvresize (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_sfdisk_N (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  int n;
  int cyls;
  int heads;
  int sectors;
  const char *line;

  if (!PyArg_ParseTuple (args, (char *) "Osiiiis:guestfs_sfdisk_N",
                         &py_g, &device, &n, &cyls, &heads, &sectors, &line))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_sfdisk_l (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sfdisk_l (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_sfdisk_kernel_geometry (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sfdisk_kernel_geometry (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char *r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sfdisk_disk_geometry (g, device);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyString_FromString (r);
  free (r);
  return py_r;
}

static PyObject *
py_guestfs_vg_activate_all (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int activate;

  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all",
                         &py_g, &activate))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_vg_activate_all (g, activate);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_vg_activate (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int activate;
  PyObject *py_volgroups;
  const char **volgroups;

  if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate",
                         &py_g, &activate, &py_volgroups))
    return NULL;
  g = get_handle (py_g);
  volgroups = get_string_list (py_volgroups);
  if (!volgroups) return NULL;

  r = guestfs_vg_activate (g, activate, volgroups);
  free (volgroups);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_lvresize (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;
  int mbytes;

  if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize",
                         &py_g, &device, &mbytes))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_lvresize (g, device, mbytes);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_resize2fs (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_resize2fs (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_find (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  char **r;
  const char *directory;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find",
                         &py_g, &directory))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_find (g, directory);
  if (r == NULL) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = put_string_list (r);
  free_strings (r);
  return py_r;
}

static PyObject *
py_guestfs_e2fsck_f (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f",
                         &py_g, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_e2fsck_f (g, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_sleep (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int secs;

  if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep",
                         &py_g, &secs))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_sleep (g, secs);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  Py_INCREF (Py_None);
  py_r = Py_None;
  return py_r;
}

static PyObject *
py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args)
{
  PyObject *py_g;
  guestfs_h *g;
  PyObject *py_r;
  int r;
  int rw;
  const char *device;

  if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe",
                         &py_g, &rw, &device))
    return NULL;
  g = get_handle (py_g);

  r = guestfs_ntfs_3g_probe (g, rw, device);
  if (r == -1) {
    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
    return NULL;
  }

  py_r = PyInt_FromLong ((long) r);
  return py_r;
}

static PyMethodDef methods[] = {
  { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
  { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
  { (char *) "test0", py_guestfs_test0, METH_VARARGS, NULL },
  { (char *) "test0rint", py_guestfs_test0rint, METH_VARARGS, NULL },
  { (char *) "test0rinterr", py_guestfs_test0rinterr, METH_VARARGS, NULL },
  { (char *) "test0rint64", py_guestfs_test0rint64, METH_VARARGS, NULL },
  { (char *) "test0rint64err", py_guestfs_test0rint64err, METH_VARARGS, NULL },
  { (char *) "test0rbool", py_guestfs_test0rbool, METH_VARARGS, NULL },
  { (char *) "test0rboolerr", py_guestfs_test0rboolerr, METH_VARARGS, NULL },
  { (char *) "test0rconststring", py_guestfs_test0rconststring, METH_VARARGS, NULL },
  { (char *) "test0rconststringerr", py_guestfs_test0rconststringerr, METH_VARARGS, NULL },
  { (char *) "test0rstring", py_guestfs_test0rstring, METH_VARARGS, NULL },
  { (char *) "test0rstringerr", py_guestfs_test0rstringerr, METH_VARARGS, NULL },
  { (char *) "test0rstringlist", py_guestfs_test0rstringlist, METH_VARARGS, NULL },
  { (char *) "test0rstringlisterr", py_guestfs_test0rstringlisterr, METH_VARARGS, NULL },
  { (char *) "test0rintbool", py_guestfs_test0rintbool, METH_VARARGS, NULL },
  { (char *) "test0rintboolerr", py_guestfs_test0rintboolerr, METH_VARARGS, NULL },
  { (char *) "test0rpvlist", py_guestfs_test0rpvlist, METH_VARARGS, NULL },
  { (char *) "test0rpvlisterr", py_guestfs_test0rpvlisterr, METH_VARARGS, NULL },
  { (char *) "test0rvglist", py_guestfs_test0rvglist, METH_VARARGS, NULL },
  { (char *) "test0rvglisterr", py_guestfs_test0rvglisterr, METH_VARARGS, NULL },
  { (char *) "test0rlvlist", py_guestfs_test0rlvlist, METH_VARARGS, NULL },
  { (char *) "test0rlvlisterr", py_guestfs_test0rlvlisterr, METH_VARARGS, NULL },
  { (char *) "test0rstat", py_guestfs_test0rstat, METH_VARARGS, NULL },
  { (char *) "test0rstaterr", py_guestfs_test0rstaterr, METH_VARARGS, NULL },
  { (char *) "test0rstatvfs", py_guestfs_test0rstatvfs, METH_VARARGS, NULL },
  { (char *) "test0rstatvfserr", py_guestfs_test0rstatvfserr, METH_VARARGS, NULL },
  { (char *) "test0rhashtable", py_guestfs_test0rhashtable, METH_VARARGS, NULL },
  { (char *) "test0rhashtableerr", py_guestfs_test0rhashtableerr, METH_VARARGS, NULL },
  { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
  { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
  { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
  { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
  { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
  { (char *) "add_drive_ro", py_guestfs_add_drive_ro, METH_VARARGS, NULL },
  { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
  { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
  { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
  { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
  { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
  { (char *) "set_append", py_guestfs_set_append, METH_VARARGS, NULL },
  { (char *) "get_append", py_guestfs_get_append, METH_VARARGS, NULL },
  { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
  { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
  { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
  { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
  { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
  { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
  { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
  { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
  { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
  { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
  { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
  { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL },
  { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
  { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
  { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
  { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
  { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
  { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
  { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
  { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
  { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
  { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
  { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
  { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
  { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
  { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
  { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
  { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
  { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
  { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
  { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
  { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
  { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
  { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
  { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
  { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
  { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
  { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
  { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
  { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
  { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
  { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
  { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
  { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
  { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
  { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
  { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
  { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
  { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
  { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
  { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
  { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
  { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
  { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
  { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
  { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
  { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
  { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
  { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
  { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
  { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
  { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
  { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
  { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
  { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
  { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
  { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
  { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
  { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
  { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
  { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
  { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
  { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
  { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
  { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
  { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
  { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
  { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
  { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
  { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
  { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
  { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
  { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
  { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
  { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
  { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
  { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
  { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
  { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
  { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
  { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
  { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
  { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
  { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
  { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
  { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
  { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
  { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
  { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
  { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
  { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
  { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
  { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
  { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL },
  { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL },
  { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL },
  { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL },
  { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL },
  { (char *) "zerofree", py_guestfs_zerofree, METH_VARARGS, NULL },
  { (char *) "pvresize", py_guestfs_pvresize, METH_VARARGS, NULL },
  { (char *) "sfdisk_N", py_guestfs_sfdisk_N, METH_VARARGS, NULL },
  { (char *) "sfdisk_l", py_guestfs_sfdisk_l, METH_VARARGS, NULL },
  { (char *) "sfdisk_kernel_geometry", py_guestfs_sfdisk_kernel_geometry, METH_VARARGS, NULL },
  { (char *) "sfdisk_disk_geometry", py_guestfs_sfdisk_disk_geometry, METH_VARARGS, NULL },
  { (char *) "vg_activate_all", py_guestfs_vg_activate_all, METH_VARARGS, NULL },
  { (char *) "vg_activate", py_guestfs_vg_activate, METH_VARARGS, NULL },
  { (char *) "lvresize", py_guestfs_lvresize, METH_VARARGS, NULL },
  { (char *) "resize2fs", py_guestfs_resize2fs, METH_VARARGS, NULL },
  { (char *) "find", py_guestfs_find, METH_VARARGS, NULL },
  { (char *) "e2fsck_f", py_guestfs_e2fsck_f, METH_VARARGS, NULL },
  { (char *) "sleep", py_guestfs_sleep, METH_VARARGS, NULL },
  { (char *) "ntfs_3g_probe", py_guestfs_ntfs_3g_probe, METH_VARARGS, NULL },
  { NULL, NULL, 0, NULL }
};

void
initlibguestfsmod (void)
{
  static int initialized = 0;

  if (initialized) return;
  Py_InitModule ((char *) "libguestfsmod", methods);
  initialized = 1;
}