/* c/zx-hrxml-getput.c - WARNING: This file was automatically generated. DO NOT EDIT!
 * $Id$ */
/* Code generation design Copyright (c) 2006 Sampo Kellomaki (sampo@iki.fi),
 * All Rights Reserved. NO WARRANTY. See file COPYING for terms and conditions
 * of use. Some aspects of code generation were driven by schema
 * descriptions that were used as input and may be subject to their own copyright.
 * Code generation uses a template, whose copyright statement follows. */

/** getput-templ.c  -  Auxiliary functions template: cloning, freeing, walking data
 ** Copyright (c) 2006 Symlabs (symlabs@symlabs.com), All Rights Reserved.
 ** Author: Sampo Kellomaki (sampo@iki.fi)
 ** This is confidential unpublished proprietary source code of the author.
 ** NO WARRANTY, not even implied warranties. Contains trade secrets.
 ** Distribution prohibited unless authorized in writing.
 ** Licensed under Apache License 2.0, see file COPYING.
 ** Id: getput-templ.c,v 1.8 2009-08-30 15:09:26 sampo Exp $
 **
 ** 30.5.2006, created, Sampo Kellomaki (sampo@iki.fi)
 ** 6.8.2006, factored from enc-templ.c to separate file --Sampo
 **
 ** N.B: wo=wire order (needed for exc-c14n), so=schema order
 ** Edit with care! xsd2sg.pl applies various substitutions to this file.
 **/

#include <memory.h>
#include "errmac.h"
#include "zx.h"
#include "c/zx-const.h"
#include "c/zx-data.h"
#include "c/zx-hrxml-data.h"

/* FUNC(zx_hrxml_AccountingCode_GET_description) */
struct zx_str* zx_hrxml_AccountingCode_GET_description(struct zx_hrxml_AccountingCode_s* x) { return x->description; }
/* FUNC(zx_hrxml_AccountingCode_PUT_description) */
void zx_hrxml_AccountingCode_PUT_description(struct zx_hrxml_AccountingCode_s* x, struct zx_str* y) { x->description = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Achievement_NUM_Date) */

int zx_hrxml_Achievement_NUM_Date(struct zx_hrxml_Achievement_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Date; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Achievement_GET_Date) */

struct zx_elem_s* zx_hrxml_Achievement_GET_Date(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Date; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Achievement_POP_Date) */

struct zx_elem_s* zx_hrxml_Achievement_POP_Date(struct zx_hrxml_Achievement_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Date;
  if (y)
    x->Date = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Achievement_PUSH_Date) */

void zx_hrxml_Achievement_PUSH_Date(struct zx_hrxml_Achievement_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Date->g;
  x->Date = z;
}

/* FUNC(zx_hrxml_Achievement_REV_Date) */

void zx_hrxml_Achievement_REV_Date(struct zx_hrxml_Achievement_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Date;
  if (!y) return;
  x->Date = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Date->g;
    x->Date = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Achievement_PUT_Date) */

void zx_hrxml_Achievement_PUT_Date(struct zx_hrxml_Achievement_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Date;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Date = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Achievement_ADD_Date) */

void zx_hrxml_Achievement_ADD_Date(struct zx_hrxml_Achievement_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Date->g;
    x->Date = z;
    return;
  case -1:
    y = x->Date;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Date; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Achievement_DEL_Date) */

void zx_hrxml_Achievement_DEL_Date(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Date = (struct zx_elem_s*)x->Date->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Date;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Date; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Achievement_NUM_Description) */

int zx_hrxml_Achievement_NUM_Description(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Achievement_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_Achievement_GET_Description(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Achievement_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_Achievement_POP_Description(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Achievement_PUSH_Description) */

void zx_hrxml_Achievement_PUSH_Description(struct zx_hrxml_Achievement_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_Achievement_REV_Description) */

void zx_hrxml_Achievement_REV_Description(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Achievement_PUT_Description) */

void zx_hrxml_Achievement_PUT_Description(struct zx_hrxml_Achievement_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Achievement_ADD_Description) */

void zx_hrxml_Achievement_ADD_Description(struct zx_hrxml_Achievement_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Achievement_DEL_Description) */

void zx_hrxml_Achievement_DEL_Description(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Achievement_NUM_IssuingAuthority) */

int zx_hrxml_Achievement_NUM_IssuingAuthority(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IssuingAuthority; y; ++n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Achievement_GET_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_Achievement_GET_IssuingAuthority(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  for (y = x->IssuingAuthority; n>=0 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Achievement_POP_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_Achievement_POP_IssuingAuthority(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  y = x->IssuingAuthority;
  if (y)
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Achievement_PUSH_IssuingAuthority) */

void zx_hrxml_Achievement_PUSH_IssuingAuthority(struct zx_hrxml_Achievement_s* x, struct zx_hrxml_IssuingAuthority_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IssuingAuthority->gg.g;
  x->IssuingAuthority = z;
}

/* FUNC(zx_hrxml_Achievement_REV_IssuingAuthority) */

void zx_hrxml_Achievement_REV_IssuingAuthority(struct zx_hrxml_Achievement_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* nxt;
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  y = x->IssuingAuthority;
  if (!y) return;
  x->IssuingAuthority = 0;
  while (y) {
    nxt = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
    y->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Achievement_PUT_IssuingAuthority) */

void zx_hrxml_Achievement_PUT_IssuingAuthority(struct zx_hrxml_Achievement_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  y = x->IssuingAuthority;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IssuingAuthority = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Achievement_ADD_IssuingAuthority) */

void zx_hrxml_Achievement_ADD_IssuingAuthority(struct zx_hrxml_Achievement_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = z;
    return;
  case -1:
    y = x->IssuingAuthority;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Achievement_DEL_IssuingAuthority) */

void zx_hrxml_Achievement_DEL_IssuingAuthority(struct zx_hrxml_Achievement_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Achievements_NUM_Achievement) */

int zx_hrxml_Achievements_NUM_Achievement(struct zx_hrxml_Achievements_s* x)
{
  struct zx_hrxml_Achievement_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Achievement; y; ++n, y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Achievements_GET_Achievement) */

struct zx_hrxml_Achievement_s* zx_hrxml_Achievements_GET_Achievement(struct zx_hrxml_Achievements_s* x, int n)
{
  struct zx_hrxml_Achievement_s* y;
  if (!x) return 0;
  for (y = x->Achievement; n>=0 && y; --n, y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Achievements_POP_Achievement) */

struct zx_hrxml_Achievement_s* zx_hrxml_Achievements_POP_Achievement(struct zx_hrxml_Achievements_s* x)
{
  struct zx_hrxml_Achievement_s* y;
  if (!x) return 0;
  y = x->Achievement;
  if (y)
    x->Achievement = (struct zx_hrxml_Achievement_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Achievements_PUSH_Achievement) */

void zx_hrxml_Achievements_PUSH_Achievement(struct zx_hrxml_Achievements_s* x, struct zx_hrxml_Achievement_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Achievement->gg.g;
  x->Achievement = z;
}

/* FUNC(zx_hrxml_Achievements_REV_Achievement) */

void zx_hrxml_Achievements_REV_Achievement(struct zx_hrxml_Achievements_s* x)
{
  struct zx_hrxml_Achievement_s* nxt;
  struct zx_hrxml_Achievement_s* y;
  if (!x) return;
  y = x->Achievement;
  if (!y) return;
  x->Achievement = 0;
  while (y) {
    nxt = (struct zx_hrxml_Achievement_s*)y->gg.g.n;
    y->gg.g.n = &x->Achievement->gg.g;
    x->Achievement = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Achievements_PUT_Achievement) */

void zx_hrxml_Achievements_PUT_Achievement(struct zx_hrxml_Achievements_s* x, int n, struct zx_hrxml_Achievement_s* z)
{
  struct zx_hrxml_Achievement_s* y;
  if (!x || !z) return;
  y = x->Achievement;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Achievement = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Achievements_ADD_Achievement) */

void zx_hrxml_Achievements_ADD_Achievement(struct zx_hrxml_Achievements_s* x, int n, struct zx_hrxml_Achievement_s* z)
{
  struct zx_hrxml_Achievement_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Achievement->gg.g;
    x->Achievement = z;
    return;
  case -1:
    y = x->Achievement;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Achievement; n > 1 && y; --n, y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Achievements_DEL_Achievement) */

void zx_hrxml_Achievements_DEL_Achievement(struct zx_hrxml_Achievements_s* x, int n)
{
  struct zx_hrxml_Achievement_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Achievement = (struct zx_hrxml_Achievement_s*)x->Achievement->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Achievement_s*)x->Achievement;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Achievement; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Achievement_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_NUM_IdValue) */

int zx_hrxml_AffirmativeActionPlanJobGroupId_NUM_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_AffirmativeActionPlanJobGroupId_GET_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_AffirmativeActionPlanJobGroupId_POP_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_PUSH_IdValue) */

void zx_hrxml_AffirmativeActionPlanJobGroupId_PUSH_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_REV_IdValue) */

void zx_hrxml_AffirmativeActionPlanJobGroupId_REV_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_IdValue) */

void zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_ADD_IdValue) */

void zx_hrxml_AffirmativeActionPlanJobGroupId_ADD_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_DEL_IdValue) */

void zx_hrxml_AffirmativeActionPlanJobGroupId_DEL_IdValue(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_GET_idOwner) */
struct zx_str* zx_hrxml_AffirmativeActionPlanJobGroupId_GET_idOwner(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_idOwner) */
void zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_idOwner(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_GET_validFrom) */
struct zx_str* zx_hrxml_AffirmativeActionPlanJobGroupId_GET_validFrom(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_validFrom) */
void zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_validFrom(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_GET_validTo) */
struct zx_str* zx_hrxml_AffirmativeActionPlanJobGroupId_GET_validTo(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_validTo) */
void zx_hrxml_AffirmativeActionPlanJobGroupId_PUT_validTo(struct zx_hrxml_AffirmativeActionPlanJobGroupId_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_Affix_GET_type) */
struct zx_str* zx_hrxml_Affix_GET_type(struct zx_hrxml_Affix_s* x) { return x->type; }
/* FUNC(zx_hrxml_Affix_PUT_type) */
void zx_hrxml_Affix_PUT_type(struct zx_hrxml_Affix_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_FormattedName) */

int zx_hrxml_AlternateScript_NUM_FormattedName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_FormattedName) */

struct zx_elem_s* zx_hrxml_AlternateScript_GET_FormattedName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_FormattedName) */

struct zx_elem_s* zx_hrxml_AlternateScript_POP_FormattedName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedName;
  if (y)
    x->FormattedName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_FormattedName) */

void zx_hrxml_AlternateScript_PUSH_FormattedName(struct zx_hrxml_AlternateScript_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedName->g;
  x->FormattedName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_FormattedName) */

void zx_hrxml_AlternateScript_REV_FormattedName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedName;
  if (!y) return;
  x->FormattedName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedName->g;
    x->FormattedName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_FormattedName) */

void zx_hrxml_AlternateScript_PUT_FormattedName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_FormattedName) */

void zx_hrxml_AlternateScript_ADD_FormattedName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedName->g;
    x->FormattedName = z;
    return;
  case -1:
    y = x->FormattedName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_FormattedName) */

void zx_hrxml_AlternateScript_DEL_FormattedName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedName = (struct zx_elem_s*)x->FormattedName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_LegalName) */

int zx_hrxml_AlternateScript_NUM_LegalName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_LegalName) */

struct zx_elem_s* zx_hrxml_AlternateScript_GET_LegalName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->LegalName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_LegalName) */

struct zx_elem_s* zx_hrxml_AlternateScript_POP_LegalName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->LegalName;
  if (y)
    x->LegalName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_LegalName) */

void zx_hrxml_AlternateScript_PUSH_LegalName(struct zx_hrxml_AlternateScript_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->LegalName->g;
  x->LegalName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_LegalName) */

void zx_hrxml_AlternateScript_REV_LegalName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->LegalName;
  if (!y) return;
  x->LegalName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->LegalName->g;
    x->LegalName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_LegalName) */

void zx_hrxml_AlternateScript_PUT_LegalName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->LegalName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->LegalName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_LegalName) */

void zx_hrxml_AlternateScript_ADD_LegalName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->LegalName->g;
    x->LegalName = z;
    return;
  case -1:
    y = x->LegalName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_LegalName) */

void zx_hrxml_AlternateScript_DEL_LegalName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalName = (struct zx_elem_s*)x->LegalName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->LegalName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_GivenName) */

int zx_hrxml_AlternateScript_NUM_GivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->GivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_GivenName) */

struct zx_elem_s* zx_hrxml_AlternateScript_GET_GivenName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->GivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_GivenName) */

struct zx_elem_s* zx_hrxml_AlternateScript_POP_GivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->GivenName;
  if (y)
    x->GivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_GivenName) */

void zx_hrxml_AlternateScript_PUSH_GivenName(struct zx_hrxml_AlternateScript_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->GivenName->g;
  x->GivenName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_GivenName) */

void zx_hrxml_AlternateScript_REV_GivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->GivenName;
  if (!y) return;
  x->GivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->GivenName->g;
    x->GivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_GivenName) */

void zx_hrxml_AlternateScript_PUT_GivenName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->GivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->GivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_GivenName) */

void zx_hrxml_AlternateScript_ADD_GivenName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->GivenName->g;
    x->GivenName = z;
    return;
  case -1:
    y = x->GivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_GivenName) */

void zx_hrxml_AlternateScript_DEL_GivenName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->GivenName = (struct zx_elem_s*)x->GivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->GivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_PreferredGivenName) */

int zx_hrxml_AlternateScript_NUM_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredGivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_AlternateScript_GET_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PreferredGivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_AlternateScript_POP_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PreferredGivenName;
  if (y)
    x->PreferredGivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_PreferredGivenName) */

void zx_hrxml_AlternateScript_PUSH_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PreferredGivenName->g;
  x->PreferredGivenName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_PreferredGivenName) */

void zx_hrxml_AlternateScript_REV_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PreferredGivenName;
  if (!y) return;
  x->PreferredGivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_PreferredGivenName) */

void zx_hrxml_AlternateScript_PUT_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PreferredGivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PreferredGivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_PreferredGivenName) */

void zx_hrxml_AlternateScript_ADD_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = z;
    return;
  case -1:
    y = x->PreferredGivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_PreferredGivenName) */

void zx_hrxml_AlternateScript_DEL_PreferredGivenName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredGivenName = (struct zx_elem_s*)x->PreferredGivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PreferredGivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_MiddleName) */

int zx_hrxml_AlternateScript_NUM_MiddleName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MiddleName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_MiddleName) */

struct zx_elem_s* zx_hrxml_AlternateScript_GET_MiddleName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MiddleName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_MiddleName) */

struct zx_elem_s* zx_hrxml_AlternateScript_POP_MiddleName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MiddleName;
  if (y)
    x->MiddleName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_MiddleName) */

void zx_hrxml_AlternateScript_PUSH_MiddleName(struct zx_hrxml_AlternateScript_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MiddleName->g;
  x->MiddleName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_MiddleName) */

void zx_hrxml_AlternateScript_REV_MiddleName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MiddleName;
  if (!y) return;
  x->MiddleName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MiddleName->g;
    x->MiddleName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_MiddleName) */

void zx_hrxml_AlternateScript_PUT_MiddleName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MiddleName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MiddleName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_MiddleName) */

void zx_hrxml_AlternateScript_ADD_MiddleName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MiddleName->g;
    x->MiddleName = z;
    return;
  case -1:
    y = x->MiddleName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_MiddleName) */

void zx_hrxml_AlternateScript_DEL_MiddleName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MiddleName = (struct zx_elem_s*)x->MiddleName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MiddleName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_FamilyName) */

int zx_hrxml_AlternateScript_NUM_FamilyName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FamilyName; y; ++n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_AlternateScript_GET_FamilyName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  for (y = x->FamilyName; n>=0 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_AlternateScript_POP_FamilyName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  y = x->FamilyName;
  if (y)
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_FamilyName) */

void zx_hrxml_AlternateScript_PUSH_FamilyName(struct zx_hrxml_AlternateScript_s* x, struct zx_hrxml_FamilyName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->FamilyName->gg.g;
  x->FamilyName = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_FamilyName) */

void zx_hrxml_AlternateScript_REV_FamilyName(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_FamilyName_s* nxt;
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  y = x->FamilyName;
  if (!y) return;
  x->FamilyName = 0;
  while (y) {
    nxt = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
    y->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_FamilyName) */

void zx_hrxml_AlternateScript_PUT_FamilyName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  y = x->FamilyName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->FamilyName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_FamilyName) */

void zx_hrxml_AlternateScript_ADD_FamilyName(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = z;
    return;
  case -1:
    y = x->FamilyName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_FamilyName) */

void zx_hrxml_AlternateScript_DEL_FamilyName(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)x->FamilyName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_FamilyName_s*)x->FamilyName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AlternateScript_NUM_Affix) */

int zx_hrxml_AlternateScript_NUM_Affix(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_Affix_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Affix; y; ++n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AlternateScript_GET_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_AlternateScript_GET_Affix(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  for (y = x->Affix; n>=0 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_POP_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_AlternateScript_POP_Affix(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  y = x->Affix;
  if (y)
    x->Affix = (struct zx_hrxml_Affix_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AlternateScript_PUSH_Affix) */

void zx_hrxml_AlternateScript_PUSH_Affix(struct zx_hrxml_AlternateScript_s* x, struct zx_hrxml_Affix_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Affix->gg.g;
  x->Affix = z;
}

/* FUNC(zx_hrxml_AlternateScript_REV_Affix) */

void zx_hrxml_AlternateScript_REV_Affix(struct zx_hrxml_AlternateScript_s* x)
{
  struct zx_hrxml_Affix_s* nxt;
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  y = x->Affix;
  if (!y) return;
  x->Affix = 0;
  while (y) {
    nxt = (struct zx_hrxml_Affix_s*)y->gg.g.n;
    y->gg.g.n = &x->Affix->gg.g;
    x->Affix = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AlternateScript_PUT_Affix) */

void zx_hrxml_AlternateScript_PUT_Affix(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  y = x->Affix;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Affix = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AlternateScript_ADD_Affix) */

void zx_hrxml_AlternateScript_ADD_Affix(struct zx_hrxml_AlternateScript_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Affix->gg.g;
    x->Affix = z;
    return;
  case -1:
    y = x->Affix;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AlternateScript_DEL_Affix) */

void zx_hrxml_AlternateScript_DEL_Affix(struct zx_hrxml_AlternateScript_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Affix = (struct zx_hrxml_Affix_s*)x->Affix->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Affix_s*)x->Affix;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_AlternateScript_GET_script) */
struct zx_str* zx_hrxml_AlternateScript_GET_script(struct zx_hrxml_AlternateScript_s* x) { return x->script; }
/* FUNC(zx_hrxml_AlternateScript_PUT_script) */
void zx_hrxml_AlternateScript_PUT_script(struct zx_hrxml_AlternateScript_s* x, struct zx_str* y) { x->script = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Area_NUM_Value) */

int zx_hrxml_Area_NUM_Value(struct zx_hrxml_Area_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Value; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Area_GET_Value) */

struct zx_elem_s* zx_hrxml_Area_GET_Value(struct zx_hrxml_Area_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Value; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Area_POP_Value) */

struct zx_elem_s* zx_hrxml_Area_POP_Value(struct zx_hrxml_Area_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Value;
  if (y)
    x->Value = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Area_PUSH_Value) */

void zx_hrxml_Area_PUSH_Value(struct zx_hrxml_Area_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Value->g;
  x->Value = z;
}

/* FUNC(zx_hrxml_Area_REV_Value) */

void zx_hrxml_Area_REV_Value(struct zx_hrxml_Area_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Value;
  if (!y) return;
  x->Value = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Value->g;
    x->Value = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Area_PUT_Value) */

void zx_hrxml_Area_PUT_Value(struct zx_hrxml_Area_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Value;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Value = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Area_ADD_Value) */

void zx_hrxml_Area_ADD_Value(struct zx_hrxml_Area_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Value->g;
    x->Value = z;
    return;
  case -1:
    y = x->Value;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Area_DEL_Value) */

void zx_hrxml_Area_DEL_Value(struct zx_hrxml_Area_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Value = (struct zx_elem_s*)x->Value->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Value;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Area_NUM_Area) */

int zx_hrxml_Area_NUM_Area(struct zx_hrxml_Area_s* x)
{
  struct zx_hrxml_Area_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Area; y; ++n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Area_GET_Area) */

struct zx_hrxml_Area_s* zx_hrxml_Area_GET_Area(struct zx_hrxml_Area_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  for (y = x->Area; n>=0 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Area_POP_Area) */

struct zx_hrxml_Area_s* zx_hrxml_Area_POP_Area(struct zx_hrxml_Area_s* x)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  y = x->Area;
  if (y)
    x->Area = (struct zx_hrxml_Area_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Area_PUSH_Area) */

void zx_hrxml_Area_PUSH_Area(struct zx_hrxml_Area_s* x, struct zx_hrxml_Area_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Area->gg.g;
  x->Area = z;
}

/* FUNC(zx_hrxml_Area_REV_Area) */

void zx_hrxml_Area_REV_Area(struct zx_hrxml_Area_s* x)
{
  struct zx_hrxml_Area_s* nxt;
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  y = x->Area;
  if (!y) return;
  x->Area = 0;
  while (y) {
    nxt = (struct zx_hrxml_Area_s*)y->gg.g.n;
    y->gg.g.n = &x->Area->gg.g;
    x->Area = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Area_PUT_Area) */

void zx_hrxml_Area_PUT_Area(struct zx_hrxml_Area_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  y = x->Area;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Area = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Area_ADD_Area) */

void zx_hrxml_Area_ADD_Area(struct zx_hrxml_Area_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Area->gg.g;
    x->Area = z;
    return;
  case -1:
    y = x->Area;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Area_DEL_Area) */

void zx_hrxml_Area_DEL_Area(struct zx_hrxml_Area_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Area = (struct zx_hrxml_Area_s*)x->Area->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Area_s*)x->Area;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Area_GET_type) */
struct zx_str* zx_hrxml_Area_GET_type(struct zx_hrxml_Area_s* x) { return x->type; }
/* FUNC(zx_hrxml_Area_PUT_type) */
void zx_hrxml_Area_PUT_type(struct zx_hrxml_Area_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Title) */

int zx_hrxml_Article_NUM_Title(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Title) */

struct zx_elem_s* zx_hrxml_Article_GET_Title(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Title) */

struct zx_elem_s* zx_hrxml_Article_POP_Title(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Title) */

void zx_hrxml_Article_PUSH_Title(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_Article_REV_Title) */

void zx_hrxml_Article_REV_Title(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Title) */

void zx_hrxml_Article_PUT_Title(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Title) */

void zx_hrxml_Article_ADD_Title(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Title) */

void zx_hrxml_Article_DEL_Title(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Name) */

int zx_hrxml_Article_NUM_Name(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Name) */

struct zx_elem_s* zx_hrxml_Article_GET_Name(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Name) */

struct zx_elem_s* zx_hrxml_Article_POP_Name(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Name) */

void zx_hrxml_Article_PUSH_Name(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_Article_REV_Name) */

void zx_hrxml_Article_REV_Name(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Name) */

void zx_hrxml_Article_PUT_Name(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Name) */

void zx_hrxml_Article_ADD_Name(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Name) */

void zx_hrxml_Article_DEL_Name(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_PublicationDate) */

int zx_hrxml_Article_NUM_PublicationDate(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationDate; y; ++n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_Article_GET_PublicationDate(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  for (y = x->PublicationDate; n>=0 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_Article_POP_PublicationDate(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  y = x->PublicationDate;
  if (y)
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_PublicationDate) */

void zx_hrxml_Article_PUSH_PublicationDate(struct zx_hrxml_Article_s* x, struct zx_hrxml_PublicationDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationDate->gg.g;
  x->PublicationDate = z;
}

/* FUNC(zx_hrxml_Article_REV_PublicationDate) */

void zx_hrxml_Article_REV_PublicationDate(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationDate_s* nxt;
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  y = x->PublicationDate;
  if (!y) return;
  x->PublicationDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_PublicationDate) */

void zx_hrxml_Article_PUT_PublicationDate(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  y = x->PublicationDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_PublicationDate) */

void zx_hrxml_Article_ADD_PublicationDate(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = z;
    return;
  case -1:
    y = x->PublicationDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Article_DEL_PublicationDate) */

void zx_hrxml_Article_DEL_PublicationDate(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Link) */

int zx_hrxml_Article_NUM_Link(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Link) */

struct zx_elem_s* zx_hrxml_Article_GET_Link(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Link) */

struct zx_elem_s* zx_hrxml_Article_POP_Link(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Link) */

void zx_hrxml_Article_PUSH_Link(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_Article_REV_Link) */

void zx_hrxml_Article_REV_Link(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Link) */

void zx_hrxml_Article_PUT_Link(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Link) */

void zx_hrxml_Article_ADD_Link(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Link) */

void zx_hrxml_Article_DEL_Link(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Abstract) */

int zx_hrxml_Article_NUM_Abstract(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Abstract; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Abstract) */

struct zx_elem_s* zx_hrxml_Article_GET_Abstract(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Abstract; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Abstract) */

struct zx_elem_s* zx_hrxml_Article_POP_Abstract(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Abstract;
  if (y)
    x->Abstract = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Abstract) */

void zx_hrxml_Article_PUSH_Abstract(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Abstract->g;
  x->Abstract = z;
}

/* FUNC(zx_hrxml_Article_REV_Abstract) */

void zx_hrxml_Article_REV_Abstract(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Abstract;
  if (!y) return;
  x->Abstract = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Abstract->g;
    x->Abstract = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Abstract) */

void zx_hrxml_Article_PUT_Abstract(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Abstract;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Abstract = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Abstract) */

void zx_hrxml_Article_ADD_Abstract(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Abstract->g;
    x->Abstract = z;
    return;
  case -1:
    y = x->Abstract;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Abstract) */

void zx_hrxml_Article_DEL_Abstract(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Abstract = (struct zx_elem_s*)x->Abstract->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Abstract;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Copyright) */

int zx_hrxml_Article_NUM_Copyright(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Copyright; y; ++n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_Article_GET_Copyright(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  for (y = x->Copyright; n>=0 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_Article_POP_Copyright(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  y = x->Copyright;
  if (y)
    x->Copyright = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Copyright) */

void zx_hrxml_Article_PUSH_Copyright(struct zx_hrxml_Article_s* x, struct zx_hrxml_Copyright_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Copyright->gg.g;
  x->Copyright = z;
}

/* FUNC(zx_hrxml_Article_REV_Copyright) */

void zx_hrxml_Article_REV_Copyright(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_Copyright_s* nxt;
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  y = x->Copyright;
  if (!y) return;
  x->Copyright = 0;
  while (y) {
    nxt = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
    y->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Copyright) */

void zx_hrxml_Article_PUT_Copyright(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  y = x->Copyright;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Copyright = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Copyright) */

void zx_hrxml_Article_ADD_Copyright(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = z;
    return;
  case -1:
    y = x->Copyright;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Article_DEL_Copyright) */

void zx_hrxml_Article_DEL_Copyright(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Copyright = (struct zx_hrxml_Copyright_s*)x->Copyright->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Copyright_s*)x->Copyright;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Comments) */

int zx_hrxml_Article_NUM_Comments(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Comments) */

struct zx_elem_s* zx_hrxml_Article_GET_Comments(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Comments) */

struct zx_elem_s* zx_hrxml_Article_POP_Comments(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Comments) */

void zx_hrxml_Article_PUSH_Comments(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Article_REV_Comments) */

void zx_hrxml_Article_REV_Comments(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Comments) */

void zx_hrxml_Article_PUT_Comments(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Comments) */

void zx_hrxml_Article_ADD_Comments(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Comments) */

void zx_hrxml_Article_DEL_Comments(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_JournalOrSerialName) */

int zx_hrxml_Article_NUM_JournalOrSerialName(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JournalOrSerialName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_JournalOrSerialName) */

struct zx_elem_s* zx_hrxml_Article_GET_JournalOrSerialName(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->JournalOrSerialName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_JournalOrSerialName) */

struct zx_elem_s* zx_hrxml_Article_POP_JournalOrSerialName(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->JournalOrSerialName;
  if (y)
    x->JournalOrSerialName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_JournalOrSerialName) */

void zx_hrxml_Article_PUSH_JournalOrSerialName(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->JournalOrSerialName->g;
  x->JournalOrSerialName = z;
}

/* FUNC(zx_hrxml_Article_REV_JournalOrSerialName) */

void zx_hrxml_Article_REV_JournalOrSerialName(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->JournalOrSerialName;
  if (!y) return;
  x->JournalOrSerialName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->JournalOrSerialName->g;
    x->JournalOrSerialName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_JournalOrSerialName) */

void zx_hrxml_Article_PUT_JournalOrSerialName(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->JournalOrSerialName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->JournalOrSerialName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_JournalOrSerialName) */

void zx_hrxml_Article_ADD_JournalOrSerialName(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->JournalOrSerialName->g;
    x->JournalOrSerialName = z;
    return;
  case -1:
    y = x->JournalOrSerialName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JournalOrSerialName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_JournalOrSerialName) */

void zx_hrxml_Article_DEL_JournalOrSerialName(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JournalOrSerialName = (struct zx_elem_s*)x->JournalOrSerialName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->JournalOrSerialName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JournalOrSerialName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_ISSN) */

int zx_hrxml_Article_NUM_ISSN(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISSN; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_ISSN) */

struct zx_elem_s* zx_hrxml_Article_GET_ISSN(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISSN; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_ISSN) */

struct zx_elem_s* zx_hrxml_Article_POP_ISSN(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISSN;
  if (y)
    x->ISSN = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_ISSN) */

void zx_hrxml_Article_PUSH_ISSN(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISSN->g;
  x->ISSN = z;
}

/* FUNC(zx_hrxml_Article_REV_ISSN) */

void zx_hrxml_Article_REV_ISSN(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISSN;
  if (!y) return;
  x->ISSN = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISSN->g;
    x->ISSN = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_ISSN) */

void zx_hrxml_Article_PUT_ISSN(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISSN;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISSN = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_ISSN) */

void zx_hrxml_Article_ADD_ISSN(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISSN->g;
    x->ISSN = z;
    return;
  case -1:
    y = x->ISSN;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_ISSN) */

void zx_hrxml_Article_DEL_ISSN(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISSN = (struct zx_elem_s*)x->ISSN->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISSN;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Volume) */

int zx_hrxml_Article_NUM_Volume(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Volume; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Volume) */

struct zx_elem_s* zx_hrxml_Article_GET_Volume(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Volume; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Volume) */

struct zx_elem_s* zx_hrxml_Article_POP_Volume(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Volume;
  if (y)
    x->Volume = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Volume) */

void zx_hrxml_Article_PUSH_Volume(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Volume->g;
  x->Volume = z;
}

/* FUNC(zx_hrxml_Article_REV_Volume) */

void zx_hrxml_Article_REV_Volume(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Volume;
  if (!y) return;
  x->Volume = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Volume->g;
    x->Volume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Volume) */

void zx_hrxml_Article_PUT_Volume(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Volume;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Volume = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Volume) */

void zx_hrxml_Article_ADD_Volume(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Volume->g;
    x->Volume = z;
    return;
  case -1:
    y = x->Volume;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Volume; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Volume) */

void zx_hrxml_Article_DEL_Volume(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Volume = (struct zx_elem_s*)x->Volume->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Volume;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Volume; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_Issue) */

int zx_hrxml_Article_NUM_Issue(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Issue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_Issue) */

struct zx_elem_s* zx_hrxml_Article_GET_Issue(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Issue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_Issue) */

struct zx_elem_s* zx_hrxml_Article_POP_Issue(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Issue;
  if (y)
    x->Issue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_Issue) */

void zx_hrxml_Article_PUSH_Issue(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Issue->g;
  x->Issue = z;
}

/* FUNC(zx_hrxml_Article_REV_Issue) */

void zx_hrxml_Article_REV_Issue(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Issue;
  if (!y) return;
  x->Issue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Issue->g;
    x->Issue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_Issue) */

void zx_hrxml_Article_PUT_Issue(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Issue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Issue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_Issue) */

void zx_hrxml_Article_ADD_Issue(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Issue->g;
    x->Issue = z;
    return;
  case -1:
    y = x->Issue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Issue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_Issue) */

void zx_hrxml_Article_DEL_Issue(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Issue = (struct zx_elem_s*)x->Issue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Issue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Issue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_PageNumber) */

int zx_hrxml_Article_NUM_PageNumber(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PageNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_PageNumber) */

struct zx_elem_s* zx_hrxml_Article_GET_PageNumber(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PageNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_PageNumber) */

struct zx_elem_s* zx_hrxml_Article_POP_PageNumber(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PageNumber;
  if (y)
    x->PageNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_PageNumber) */

void zx_hrxml_Article_PUSH_PageNumber(struct zx_hrxml_Article_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PageNumber->g;
  x->PageNumber = z;
}

/* FUNC(zx_hrxml_Article_REV_PageNumber) */

void zx_hrxml_Article_REV_PageNumber(struct zx_hrxml_Article_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PageNumber;
  if (!y) return;
  x->PageNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PageNumber->g;
    x->PageNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_PageNumber) */

void zx_hrxml_Article_PUT_PageNumber(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PageNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PageNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_PageNumber) */

void zx_hrxml_Article_ADD_PageNumber(struct zx_hrxml_Article_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PageNumber->g;
    x->PageNumber = z;
    return;
  case -1:
    y = x->PageNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PageNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Article_DEL_PageNumber) */

void zx_hrxml_Article_DEL_PageNumber(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PageNumber = (struct zx_elem_s*)x->PageNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PageNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PageNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Article_NUM_PublicationLanguage) */

int zx_hrxml_Article_NUM_PublicationLanguage(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationLanguage; y; ++n, y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Article_GET_PublicationLanguage) */

struct zx_hrxml_PublicationLanguage_s* zx_hrxml_Article_GET_PublicationLanguage(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x) return 0;
  for (y = x->PublicationLanguage; n>=0 && y; --n, y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Article_POP_PublicationLanguage) */

struct zx_hrxml_PublicationLanguage_s* zx_hrxml_Article_POP_PublicationLanguage(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x) return 0;
  y = x->PublicationLanguage;
  if (y)
    x->PublicationLanguage = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Article_PUSH_PublicationLanguage) */

void zx_hrxml_Article_PUSH_PublicationLanguage(struct zx_hrxml_Article_s* x, struct zx_hrxml_PublicationLanguage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationLanguage->gg.g;
  x->PublicationLanguage = z;
}

/* FUNC(zx_hrxml_Article_REV_PublicationLanguage) */

void zx_hrxml_Article_REV_PublicationLanguage(struct zx_hrxml_Article_s* x)
{
  struct zx_hrxml_PublicationLanguage_s* nxt;
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x) return;
  y = x->PublicationLanguage;
  if (!y) return;
  x->PublicationLanguage = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationLanguage->gg.g;
    x->PublicationLanguage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Article_PUT_PublicationLanguage) */

void zx_hrxml_Article_PUT_PublicationLanguage(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_PublicationLanguage_s* z)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x || !z) return;
  y = x->PublicationLanguage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationLanguage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Article_ADD_PublicationLanguage) */

void zx_hrxml_Article_ADD_PublicationLanguage(struct zx_hrxml_Article_s* x, int n, struct zx_hrxml_PublicationLanguage_s* z)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationLanguage->gg.g;
    x->PublicationLanguage = z;
    return;
  case -1:
    y = x->PublicationLanguage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationLanguage; n > 1 && y; --n, y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Article_DEL_PublicationLanguage) */

void zx_hrxml_Article_DEL_PublicationLanguage(struct zx_hrxml_Article_s* x, int n)
{
  struct zx_hrxml_PublicationLanguage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationLanguage = (struct zx_hrxml_PublicationLanguage_s*)x->PublicationLanguage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationLanguage_s*)x->PublicationLanguage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationLanguage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_Name) */

int zx_hrxml_Association_NUM_Name(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_Name) */

struct zx_elem_s* zx_hrxml_Association_GET_Name(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_Name) */

struct zx_elem_s* zx_hrxml_Association_POP_Name(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_Name) */

void zx_hrxml_Association_PUSH_Name(struct zx_hrxml_Association_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_Association_REV_Name) */

void zx_hrxml_Association_REV_Name(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_Name) */

void zx_hrxml_Association_PUT_Name(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_Name) */

void zx_hrxml_Association_ADD_Name(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Association_DEL_Name) */

void zx_hrxml_Association_DEL_Name(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_Id) */

int zx_hrxml_Association_NUM_Id(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Association_GET_Id(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Association_POP_Id(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_Id) */

void zx_hrxml_Association_PUSH_Id(struct zx_hrxml_Association_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_Association_REV_Id) */

void zx_hrxml_Association_REV_Id(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_Id) */

void zx_hrxml_Association_PUT_Id(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_Id) */

void zx_hrxml_Association_ADD_Id(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Association_DEL_Id) */

void zx_hrxml_Association_DEL_Id(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_Link) */

int zx_hrxml_Association_NUM_Link(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_Link) */

struct zx_elem_s* zx_hrxml_Association_GET_Link(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_Link) */

struct zx_elem_s* zx_hrxml_Association_POP_Link(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_Link) */

void zx_hrxml_Association_PUSH_Link(struct zx_hrxml_Association_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_Association_REV_Link) */

void zx_hrxml_Association_REV_Link(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_Link) */

void zx_hrxml_Association_PUT_Link(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_Link) */

void zx_hrxml_Association_ADD_Link(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Association_DEL_Link) */

void zx_hrxml_Association_DEL_Link(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_StartDate) */

int zx_hrxml_Association_NUM_StartDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_Association_GET_StartDate(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_Association_POP_StartDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_StartDate) */

void zx_hrxml_Association_PUSH_StartDate(struct zx_hrxml_Association_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_Association_REV_StartDate) */

void zx_hrxml_Association_REV_StartDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_StartDate) */

void zx_hrxml_Association_PUT_StartDate(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_StartDate) */

void zx_hrxml_Association_ADD_StartDate(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Association_DEL_StartDate) */

void zx_hrxml_Association_DEL_StartDate(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_EndDate) */

int zx_hrxml_Association_NUM_EndDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_Association_GET_EndDate(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_Association_POP_EndDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_EndDate) */

void zx_hrxml_Association_PUSH_EndDate(struct zx_hrxml_Association_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_Association_REV_EndDate) */

void zx_hrxml_Association_REV_EndDate(struct zx_hrxml_Association_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_EndDate) */

void zx_hrxml_Association_PUT_EndDate(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_EndDate) */

void zx_hrxml_Association_ADD_EndDate(struct zx_hrxml_Association_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Association_DEL_EndDate) */

void zx_hrxml_Association_DEL_EndDate(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_Role) */

int zx_hrxml_Association_NUM_Role(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Role; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_Role) */

struct zx_elem_s* zx_hrxml_Association_GET_Role(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Role; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_Role) */

struct zx_elem_s* zx_hrxml_Association_POP_Role(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Role;
  if (y)
    x->Role = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_Role) */

void zx_hrxml_Association_PUSH_Role(struct zx_hrxml_Association_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Role->g;
  x->Role = z;
}

/* FUNC(zx_hrxml_Association_REV_Role) */

void zx_hrxml_Association_REV_Role(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Role;
  if (!y) return;
  x->Role = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Role->g;
    x->Role = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_Role) */

void zx_hrxml_Association_PUT_Role(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Role;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Role = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_Role) */

void zx_hrxml_Association_ADD_Role(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Role->g;
    x->Role = z;
    return;
  case -1:
    y = x->Role;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Role; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Association_DEL_Role) */

void zx_hrxml_Association_DEL_Role(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Role = (struct zx_elem_s*)x->Role->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Role;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Role; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Association_NUM_Comments) */

int zx_hrxml_Association_NUM_Comments(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Association_GET_Comments) */

struct zx_elem_s* zx_hrxml_Association_GET_Comments(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Association_POP_Comments) */

struct zx_elem_s* zx_hrxml_Association_POP_Comments(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Association_PUSH_Comments) */

void zx_hrxml_Association_PUSH_Comments(struct zx_hrxml_Association_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Association_REV_Comments) */

void zx_hrxml_Association_REV_Comments(struct zx_hrxml_Association_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Association_PUT_Comments) */

void zx_hrxml_Association_PUT_Comments(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Association_ADD_Comments) */

void zx_hrxml_Association_ADD_Comments(struct zx_hrxml_Association_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Association_DEL_Comments) */

void zx_hrxml_Association_DEL_Comments(struct zx_hrxml_Association_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Association_GET_type) */
struct zx_str* zx_hrxml_Association_GET_type(struct zx_hrxml_Association_s* x) { return x->type; }
/* FUNC(zx_hrxml_Association_PUT_type) */
void zx_hrxml_Association_PUT_type(struct zx_hrxml_Association_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Associations_NUM_Association) */

int zx_hrxml_Associations_NUM_Association(struct zx_hrxml_Associations_s* x)
{
  struct zx_hrxml_Association_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Association; y; ++n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Associations_GET_Association) */

struct zx_hrxml_Association_s* zx_hrxml_Associations_GET_Association(struct zx_hrxml_Associations_s* x, int n)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return 0;
  for (y = x->Association; n>=0 && y; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Associations_POP_Association) */

struct zx_hrxml_Association_s* zx_hrxml_Associations_POP_Association(struct zx_hrxml_Associations_s* x)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return 0;
  y = x->Association;
  if (y)
    x->Association = (struct zx_hrxml_Association_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Associations_PUSH_Association) */

void zx_hrxml_Associations_PUSH_Association(struct zx_hrxml_Associations_s* x, struct zx_hrxml_Association_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Association->gg.g;
  x->Association = z;
}

/* FUNC(zx_hrxml_Associations_REV_Association) */

void zx_hrxml_Associations_REV_Association(struct zx_hrxml_Associations_s* x)
{
  struct zx_hrxml_Association_s* nxt;
  struct zx_hrxml_Association_s* y;
  if (!x) return;
  y = x->Association;
  if (!y) return;
  x->Association = 0;
  while (y) {
    nxt = (struct zx_hrxml_Association_s*)y->gg.g.n;
    y->gg.g.n = &x->Association->gg.g;
    x->Association = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Associations_PUT_Association) */

void zx_hrxml_Associations_PUT_Association(struct zx_hrxml_Associations_s* x, int n, struct zx_hrxml_Association_s* z)
{
  struct zx_hrxml_Association_s* y;
  if (!x || !z) return;
  y = x->Association;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Association = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Associations_ADD_Association) */

void zx_hrxml_Associations_ADD_Association(struct zx_hrxml_Associations_s* x, int n, struct zx_hrxml_Association_s* z)
{
  struct zx_hrxml_Association_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Association->gg.g;
    x->Association = z;
    return;
  case -1:
    y = x->Association;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Association; n > 1 && y; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Associations_DEL_Association) */

void zx_hrxml_Associations_DEL_Association(struct zx_hrxml_Associations_s* x, int n)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Association = (struct zx_hrxml_Association_s*)x->Association->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Association_s*)x->Association;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Association; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_AttachmentReference_GET_context) */
struct zx_str* zx_hrxml_AttachmentReference_GET_context(struct zx_hrxml_AttachmentReference_s* x) { return x->context; }
/* FUNC(zx_hrxml_AttachmentReference_PUT_context) */
void zx_hrxml_AttachmentReference_PUT_context(struct zx_hrxml_AttachmentReference_s* x, struct zx_str* y) { x->context = y; }
/* FUNC(zx_hrxml_AttachmentReference_GET_mimeType) */
struct zx_str* zx_hrxml_AttachmentReference_GET_mimeType(struct zx_hrxml_AttachmentReference_s* x) { return x->mimeType; }
/* FUNC(zx_hrxml_AttachmentReference_PUT_mimeType) */
void zx_hrxml_AttachmentReference_PUT_mimeType(struct zx_hrxml_AttachmentReference_s* x, struct zx_str* y) { x->mimeType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AvailabilityDates_NUM_StartDate) */

int zx_hrxml_AvailabilityDates_NUM_StartDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AvailabilityDates_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_AvailabilityDates_GET_StartDate(struct zx_hrxml_AvailabilityDates_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityDates_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_AvailabilityDates_POP_StartDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityDates_PUSH_StartDate) */

void zx_hrxml_AvailabilityDates_PUSH_StartDate(struct zx_hrxml_AvailabilityDates_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_AvailabilityDates_REV_StartDate) */

void zx_hrxml_AvailabilityDates_REV_StartDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AvailabilityDates_PUT_StartDate) */

void zx_hrxml_AvailabilityDates_PUT_StartDate(struct zx_hrxml_AvailabilityDates_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AvailabilityDates_ADD_StartDate) */

void zx_hrxml_AvailabilityDates_ADD_StartDate(struct zx_hrxml_AvailabilityDates_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AvailabilityDates_DEL_StartDate) */

void zx_hrxml_AvailabilityDates_DEL_StartDate(struct zx_hrxml_AvailabilityDates_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AvailabilityDates_NUM_EndDate) */

int zx_hrxml_AvailabilityDates_NUM_EndDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AvailabilityDates_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_AvailabilityDates_GET_EndDate(struct zx_hrxml_AvailabilityDates_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityDates_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_AvailabilityDates_POP_EndDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityDates_PUSH_EndDate) */

void zx_hrxml_AvailabilityDates_PUSH_EndDate(struct zx_hrxml_AvailabilityDates_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_AvailabilityDates_REV_EndDate) */

void zx_hrxml_AvailabilityDates_REV_EndDate(struct zx_hrxml_AvailabilityDates_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AvailabilityDates_PUT_EndDate) */

void zx_hrxml_AvailabilityDates_PUT_EndDate(struct zx_hrxml_AvailabilityDates_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AvailabilityDates_ADD_EndDate) */

void zx_hrxml_AvailabilityDates_ADD_EndDate(struct zx_hrxml_AvailabilityDates_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AvailabilityDates_DEL_EndDate) */

void zx_hrxml_AvailabilityDates_DEL_EndDate(struct zx_hrxml_AvailabilityDates_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AvailabilityInfo_NUM_AvailabilityDates) */

int zx_hrxml_AvailabilityInfo_NUM_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AvailabilityDates; y; ++n, y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AvailabilityInfo_GET_AvailabilityDates) */

struct zx_hrxml_AvailabilityDates_s* zx_hrxml_AvailabilityInfo_GET_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x, int n)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x) return 0;
  for (y = x->AvailabilityDates; n>=0 && y; --n, y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityInfo_POP_AvailabilityDates) */

struct zx_hrxml_AvailabilityDates_s* zx_hrxml_AvailabilityInfo_POP_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x) return 0;
  y = x->AvailabilityDates;
  if (y)
    x->AvailabilityDates = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityInfo_PUSH_AvailabilityDates) */

void zx_hrxml_AvailabilityInfo_PUSH_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x, struct zx_hrxml_AvailabilityDates_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AvailabilityDates->gg.g;
  x->AvailabilityDates = z;
}

/* FUNC(zx_hrxml_AvailabilityInfo_REV_AvailabilityDates) */

void zx_hrxml_AvailabilityInfo_REV_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_AvailabilityDates_s* nxt;
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x) return;
  y = x->AvailabilityDates;
  if (!y) return;
  x->AvailabilityDates = 0;
  while (y) {
    nxt = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n;
    y->gg.g.n = &x->AvailabilityDates->gg.g;
    x->AvailabilityDates = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AvailabilityInfo_PUT_AvailabilityDates) */

void zx_hrxml_AvailabilityInfo_PUT_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x, int n, struct zx_hrxml_AvailabilityDates_s* z)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x || !z) return;
  y = x->AvailabilityDates;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AvailabilityDates = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AvailabilityInfo_ADD_AvailabilityDates) */

void zx_hrxml_AvailabilityInfo_ADD_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x, int n, struct zx_hrxml_AvailabilityDates_s* z)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AvailabilityDates->gg.g;
    x->AvailabilityDates = z;
    return;
  case -1:
    y = x->AvailabilityDates;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AvailabilityDates; n > 1 && y; --n, y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AvailabilityInfo_DEL_AvailabilityDates) */

void zx_hrxml_AvailabilityInfo_DEL_AvailabilityDates(struct zx_hrxml_AvailabilityInfo_s* x, int n)
{
  struct zx_hrxml_AvailabilityDates_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AvailabilityDates = (struct zx_hrxml_AvailabilityDates_s*)x->AvailabilityDates->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AvailabilityDates_s*)x->AvailabilityDates;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AvailabilityDates; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AvailabilityDates_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_AvailabilityInfo_NUM_TermOfNotice) */

int zx_hrxml_AvailabilityInfo_NUM_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_TermOfNotice_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TermOfNotice; y; ++n, y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_AvailabilityInfo_GET_TermOfNotice) */

struct zx_hrxml_TermOfNotice_s* zx_hrxml_AvailabilityInfo_GET_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x, int n)
{
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x) return 0;
  for (y = x->TermOfNotice; n>=0 && y; --n, y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityInfo_POP_TermOfNotice) */

struct zx_hrxml_TermOfNotice_s* zx_hrxml_AvailabilityInfo_POP_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x) return 0;
  y = x->TermOfNotice;
  if (y)
    x->TermOfNotice = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_AvailabilityInfo_PUSH_TermOfNotice) */

void zx_hrxml_AvailabilityInfo_PUSH_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x, struct zx_hrxml_TermOfNotice_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TermOfNotice->gg.g;
  x->TermOfNotice = z;
}

/* FUNC(zx_hrxml_AvailabilityInfo_REV_TermOfNotice) */

void zx_hrxml_AvailabilityInfo_REV_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x)
{
  struct zx_hrxml_TermOfNotice_s* nxt;
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x) return;
  y = x->TermOfNotice;
  if (!y) return;
  x->TermOfNotice = 0;
  while (y) {
    nxt = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n;
    y->gg.g.n = &x->TermOfNotice->gg.g;
    x->TermOfNotice = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_AvailabilityInfo_PUT_TermOfNotice) */

void zx_hrxml_AvailabilityInfo_PUT_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x, int n, struct zx_hrxml_TermOfNotice_s* z)
{
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x || !z) return;
  y = x->TermOfNotice;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TermOfNotice = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_AvailabilityInfo_ADD_TermOfNotice) */

void zx_hrxml_AvailabilityInfo_ADD_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x, int n, struct zx_hrxml_TermOfNotice_s* z)
{
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TermOfNotice->gg.g;
    x->TermOfNotice = z;
    return;
  case -1:
    y = x->TermOfNotice;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TermOfNotice; n > 1 && y; --n, y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_AvailabilityInfo_DEL_TermOfNotice) */

void zx_hrxml_AvailabilityInfo_DEL_TermOfNotice(struct zx_hrxml_AvailabilityInfo_s* x, int n)
{
  struct zx_hrxml_TermOfNotice_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TermOfNotice = (struct zx_hrxml_TermOfNotice_s*)x->TermOfNotice->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TermOfNotice_s*)x->TermOfNotice;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TermOfNotice; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TermOfNotice_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BKZClassification_NUM_BKZId) */

int zx_hrxml_BKZClassification_NUM_BKZId(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_hrxml_BKZId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BKZId; y; ++n, y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BKZClassification_GET_BKZId) */

struct zx_hrxml_BKZId_s* zx_hrxml_BKZClassification_GET_BKZId(struct zx_hrxml_BKZClassification_s* x, int n)
{
  struct zx_hrxml_BKZId_s* y;
  if (!x) return 0;
  for (y = x->BKZId; n>=0 && y; --n, y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BKZClassification_POP_BKZId) */

struct zx_hrxml_BKZId_s* zx_hrxml_BKZClassification_POP_BKZId(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_hrxml_BKZId_s* y;
  if (!x) return 0;
  y = x->BKZId;
  if (y)
    x->BKZId = (struct zx_hrxml_BKZId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BKZClassification_PUSH_BKZId) */

void zx_hrxml_BKZClassification_PUSH_BKZId(struct zx_hrxml_BKZClassification_s* x, struct zx_hrxml_BKZId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->BKZId->gg.g;
  x->BKZId = z;
}

/* FUNC(zx_hrxml_BKZClassification_REV_BKZId) */

void zx_hrxml_BKZClassification_REV_BKZId(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_hrxml_BKZId_s* nxt;
  struct zx_hrxml_BKZId_s* y;
  if (!x) return;
  y = x->BKZId;
  if (!y) return;
  x->BKZId = 0;
  while (y) {
    nxt = (struct zx_hrxml_BKZId_s*)y->gg.g.n;
    y->gg.g.n = &x->BKZId->gg.g;
    x->BKZId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BKZClassification_PUT_BKZId) */

void zx_hrxml_BKZClassification_PUT_BKZId(struct zx_hrxml_BKZClassification_s* x, int n, struct zx_hrxml_BKZId_s* z)
{
  struct zx_hrxml_BKZId_s* y;
  if (!x || !z) return;
  y = x->BKZId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->BKZId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BKZClassification_ADD_BKZId) */

void zx_hrxml_BKZClassification_ADD_BKZId(struct zx_hrxml_BKZClassification_s* x, int n, struct zx_hrxml_BKZId_s* z)
{
  struct zx_hrxml_BKZId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->BKZId->gg.g;
    x->BKZId = z;
    return;
  case -1:
    y = x->BKZId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BKZId; n > 1 && y; --n, y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BKZClassification_DEL_BKZId) */

void zx_hrxml_BKZClassification_DEL_BKZId(struct zx_hrxml_BKZClassification_s* x, int n)
{
  struct zx_hrxml_BKZId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BKZId = (struct zx_hrxml_BKZId_s*)x->BKZId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_BKZId_s*)x->BKZId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BKZId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BKZId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BKZClassification_NUM_BKZName) */

int zx_hrxml_BKZClassification_NUM_BKZName(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BKZName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BKZClassification_GET_BKZName) */

struct zx_elem_s* zx_hrxml_BKZClassification_GET_BKZName(struct zx_hrxml_BKZClassification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->BKZName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BKZClassification_POP_BKZName) */

struct zx_elem_s* zx_hrxml_BKZClassification_POP_BKZName(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->BKZName;
  if (y)
    x->BKZName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BKZClassification_PUSH_BKZName) */

void zx_hrxml_BKZClassification_PUSH_BKZName(struct zx_hrxml_BKZClassification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->BKZName->g;
  x->BKZName = z;
}

/* FUNC(zx_hrxml_BKZClassification_REV_BKZName) */

void zx_hrxml_BKZClassification_REV_BKZName(struct zx_hrxml_BKZClassification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->BKZName;
  if (!y) return;
  x->BKZName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->BKZName->g;
    x->BKZName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BKZClassification_PUT_BKZName) */

void zx_hrxml_BKZClassification_PUT_BKZName(struct zx_hrxml_BKZClassification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->BKZName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->BKZName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BKZClassification_ADD_BKZName) */

void zx_hrxml_BKZClassification_ADD_BKZName(struct zx_hrxml_BKZClassification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->BKZName->g;
    x->BKZName = z;
    return;
  case -1:
    y = x->BKZName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BKZName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BKZClassification_DEL_BKZName) */

void zx_hrxml_BKZClassification_DEL_BKZName(struct zx_hrxml_BKZClassification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BKZName = (struct zx_elem_s*)x->BKZName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->BKZName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BKZName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BKZId_NUM_IdValue) */

int zx_hrxml_BKZId_NUM_IdValue(struct zx_hrxml_BKZId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BKZId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_BKZId_GET_IdValue(struct zx_hrxml_BKZId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BKZId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_BKZId_POP_IdValue(struct zx_hrxml_BKZId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BKZId_PUSH_IdValue) */

void zx_hrxml_BKZId_PUSH_IdValue(struct zx_hrxml_BKZId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_BKZId_REV_IdValue) */

void zx_hrxml_BKZId_REV_IdValue(struct zx_hrxml_BKZId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BKZId_PUT_IdValue) */

void zx_hrxml_BKZId_PUT_IdValue(struct zx_hrxml_BKZId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BKZId_ADD_IdValue) */

void zx_hrxml_BKZId_ADD_IdValue(struct zx_hrxml_BKZId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BKZId_DEL_IdValue) */

void zx_hrxml_BKZId_DEL_IdValue(struct zx_hrxml_BKZId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_BKZId_GET_idOwner) */
struct zx_str* zx_hrxml_BKZId_GET_idOwner(struct zx_hrxml_BKZId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_BKZId_PUT_idOwner) */
void zx_hrxml_BKZId_PUT_idOwner(struct zx_hrxml_BKZId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_BKZId_GET_validFrom) */
struct zx_str* zx_hrxml_BKZId_GET_validFrom(struct zx_hrxml_BKZId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_BKZId_PUT_validFrom) */
void zx_hrxml_BKZId_PUT_validFrom(struct zx_hrxml_BKZId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_BKZId_GET_validTo) */
struct zx_str* zx_hrxml_BKZId_GET_validTo(struct zx_hrxml_BKZId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_BKZId_PUT_validTo) */
void zx_hrxml_BKZId_PUT_validTo(struct zx_hrxml_BKZId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BasePay_NUM_BasePayAmountMin) */

int zx_hrxml_BasePay_NUM_BasePayAmountMin(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BasePayAmountMin; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BasePay_GET_BasePayAmountMin) */

struct zx_elem_s* zx_hrxml_BasePay_GET_BasePayAmountMin(struct zx_hrxml_BasePay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->BasePayAmountMin; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BasePay_POP_BasePayAmountMin) */

struct zx_elem_s* zx_hrxml_BasePay_POP_BasePayAmountMin(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->BasePayAmountMin;
  if (y)
    x->BasePayAmountMin = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BasePay_PUSH_BasePayAmountMin) */

void zx_hrxml_BasePay_PUSH_BasePayAmountMin(struct zx_hrxml_BasePay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->BasePayAmountMin->g;
  x->BasePayAmountMin = z;
}

/* FUNC(zx_hrxml_BasePay_REV_BasePayAmountMin) */

void zx_hrxml_BasePay_REV_BasePayAmountMin(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->BasePayAmountMin;
  if (!y) return;
  x->BasePayAmountMin = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->BasePayAmountMin->g;
    x->BasePayAmountMin = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BasePay_PUT_BasePayAmountMin) */

void zx_hrxml_BasePay_PUT_BasePayAmountMin(struct zx_hrxml_BasePay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->BasePayAmountMin;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->BasePayAmountMin = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BasePay_ADD_BasePayAmountMin) */

void zx_hrxml_BasePay_ADD_BasePayAmountMin(struct zx_hrxml_BasePay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->BasePayAmountMin->g;
    x->BasePayAmountMin = z;
    return;
  case -1:
    y = x->BasePayAmountMin;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BasePayAmountMin; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BasePay_DEL_BasePayAmountMin) */

void zx_hrxml_BasePay_DEL_BasePayAmountMin(struct zx_hrxml_BasePay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BasePayAmountMin = (struct zx_elem_s*)x->BasePayAmountMin->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->BasePayAmountMin;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BasePayAmountMin; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BasePay_NUM_BasePayAmountMax) */

int zx_hrxml_BasePay_NUM_BasePayAmountMax(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BasePayAmountMax; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BasePay_GET_BasePayAmountMax) */

struct zx_elem_s* zx_hrxml_BasePay_GET_BasePayAmountMax(struct zx_hrxml_BasePay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->BasePayAmountMax; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BasePay_POP_BasePayAmountMax) */

struct zx_elem_s* zx_hrxml_BasePay_POP_BasePayAmountMax(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->BasePayAmountMax;
  if (y)
    x->BasePayAmountMax = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BasePay_PUSH_BasePayAmountMax) */

void zx_hrxml_BasePay_PUSH_BasePayAmountMax(struct zx_hrxml_BasePay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->BasePayAmountMax->g;
  x->BasePayAmountMax = z;
}

/* FUNC(zx_hrxml_BasePay_REV_BasePayAmountMax) */

void zx_hrxml_BasePay_REV_BasePayAmountMax(struct zx_hrxml_BasePay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->BasePayAmountMax;
  if (!y) return;
  x->BasePayAmountMax = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->BasePayAmountMax->g;
    x->BasePayAmountMax = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BasePay_PUT_BasePayAmountMax) */

void zx_hrxml_BasePay_PUT_BasePayAmountMax(struct zx_hrxml_BasePay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->BasePayAmountMax;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->BasePayAmountMax = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BasePay_ADD_BasePayAmountMax) */

void zx_hrxml_BasePay_ADD_BasePayAmountMax(struct zx_hrxml_BasePay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->BasePayAmountMax->g;
    x->BasePayAmountMax = z;
    return;
  case -1:
    y = x->BasePayAmountMax;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BasePayAmountMax; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BasePay_DEL_BasePayAmountMax) */

void zx_hrxml_BasePay_DEL_BasePayAmountMax(struct zx_hrxml_BasePay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BasePayAmountMax = (struct zx_elem_s*)x->BasePayAmountMax->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->BasePayAmountMax;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BasePayAmountMax; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_BasePay_GET_baseInterval) */
struct zx_str* zx_hrxml_BasePay_GET_baseInterval(struct zx_hrxml_BasePay_s* x) { return x->baseInterval; }
/* FUNC(zx_hrxml_BasePay_PUT_baseInterval) */
void zx_hrxml_BasePay_PUT_baseInterval(struct zx_hrxml_BasePay_s* x, struct zx_str* y) { x->baseInterval = y; }
/* FUNC(zx_hrxml_BasePay_GET_currencyCode) */
struct zx_str* zx_hrxml_BasePay_GET_currencyCode(struct zx_hrxml_BasePay_s* x) { return x->currencyCode; }
/* FUNC(zx_hrxml_BasePay_PUT_currencyCode) */
void zx_hrxml_BasePay_PUT_currencyCode(struct zx_hrxml_BasePay_s* x, struct zx_str* y) { x->currencyCode = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_Insurance) */

int zx_hrxml_Benefits_NUM_Insurance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_Insurance_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Insurance; y; ++n, y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_Insurance) */

struct zx_hrxml_Insurance_s* zx_hrxml_Benefits_GET_Insurance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_Insurance_s* y;
  if (!x) return 0;
  for (y = x->Insurance; n>=0 && y; --n, y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_Insurance) */

struct zx_hrxml_Insurance_s* zx_hrxml_Benefits_POP_Insurance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_Insurance_s* y;
  if (!x) return 0;
  y = x->Insurance;
  if (y)
    x->Insurance = (struct zx_hrxml_Insurance_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_Insurance) */

void zx_hrxml_Benefits_PUSH_Insurance(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_Insurance_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Insurance->gg.g;
  x->Insurance = z;
}

/* FUNC(zx_hrxml_Benefits_REV_Insurance) */

void zx_hrxml_Benefits_REV_Insurance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_Insurance_s* nxt;
  struct zx_hrxml_Insurance_s* y;
  if (!x) return;
  y = x->Insurance;
  if (!y) return;
  x->Insurance = 0;
  while (y) {
    nxt = (struct zx_hrxml_Insurance_s*)y->gg.g.n;
    y->gg.g.n = &x->Insurance->gg.g;
    x->Insurance = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_Insurance) */

void zx_hrxml_Benefits_PUT_Insurance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_Insurance_s* z)
{
  struct zx_hrxml_Insurance_s* y;
  if (!x || !z) return;
  y = x->Insurance;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Insurance = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_Insurance) */

void zx_hrxml_Benefits_ADD_Insurance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_Insurance_s* z)
{
  struct zx_hrxml_Insurance_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Insurance->gg.g;
    x->Insurance = z;
    return;
  case -1:
    y = x->Insurance;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Insurance; n > 1 && y; --n, y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_Insurance) */

void zx_hrxml_Benefits_DEL_Insurance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_Insurance_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Insurance = (struct zx_hrxml_Insurance_s*)x->Insurance->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Insurance_s*)x->Insurance;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Insurance; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Insurance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_RetirementOrSavingsPlan) */

int zx_hrxml_Benefits_NUM_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RetirementOrSavingsPlan; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_RetirementOrSavingsPlan) */

struct zx_elem_s* zx_hrxml_Benefits_GET_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->RetirementOrSavingsPlan; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_RetirementOrSavingsPlan) */

struct zx_elem_s* zx_hrxml_Benefits_POP_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->RetirementOrSavingsPlan;
  if (y)
    x->RetirementOrSavingsPlan = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_RetirementOrSavingsPlan) */

void zx_hrxml_Benefits_PUSH_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->RetirementOrSavingsPlan->g;
  x->RetirementOrSavingsPlan = z;
}

/* FUNC(zx_hrxml_Benefits_REV_RetirementOrSavingsPlan) */

void zx_hrxml_Benefits_REV_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->RetirementOrSavingsPlan;
  if (!y) return;
  x->RetirementOrSavingsPlan = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->RetirementOrSavingsPlan->g;
    x->RetirementOrSavingsPlan = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_RetirementOrSavingsPlan) */

void zx_hrxml_Benefits_PUT_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->RetirementOrSavingsPlan;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->RetirementOrSavingsPlan = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_RetirementOrSavingsPlan) */

void zx_hrxml_Benefits_ADD_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->RetirementOrSavingsPlan->g;
    x->RetirementOrSavingsPlan = z;
    return;
  case -1:
    y = x->RetirementOrSavingsPlan;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RetirementOrSavingsPlan; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Benefits_DEL_RetirementOrSavingsPlan) */

void zx_hrxml_Benefits_DEL_RetirementOrSavingsPlan(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RetirementOrSavingsPlan = (struct zx_elem_s*)x->RetirementOrSavingsPlan->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->RetirementOrSavingsPlan;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RetirementOrSavingsPlan; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_CompanyVehicle) */

int zx_hrxml_Benefits_NUM_CompanyVehicle(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompanyVehicle; y; ++n, y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_CompanyVehicle) */

struct zx_hrxml_CompanyVehicle_s* zx_hrxml_Benefits_GET_CompanyVehicle(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x) return 0;
  for (y = x->CompanyVehicle; n>=0 && y; --n, y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_CompanyVehicle) */

struct zx_hrxml_CompanyVehicle_s* zx_hrxml_Benefits_POP_CompanyVehicle(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x) return 0;
  y = x->CompanyVehicle;
  if (y)
    x->CompanyVehicle = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_CompanyVehicle) */

void zx_hrxml_Benefits_PUSH_CompanyVehicle(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_CompanyVehicle_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CompanyVehicle->gg.g;
  x->CompanyVehicle = z;
}

/* FUNC(zx_hrxml_Benefits_REV_CompanyVehicle) */

void zx_hrxml_Benefits_REV_CompanyVehicle(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_CompanyVehicle_s* nxt;
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x) return;
  y = x->CompanyVehicle;
  if (!y) return;
  x->CompanyVehicle = 0;
  while (y) {
    nxt = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n;
    y->gg.g.n = &x->CompanyVehicle->gg.g;
    x->CompanyVehicle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_CompanyVehicle) */

void zx_hrxml_Benefits_PUT_CompanyVehicle(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_CompanyVehicle_s* z)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x || !z) return;
  y = x->CompanyVehicle;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CompanyVehicle = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_CompanyVehicle) */

void zx_hrxml_Benefits_ADD_CompanyVehicle(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_CompanyVehicle_s* z)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CompanyVehicle->gg.g;
    x->CompanyVehicle = z;
    return;
  case -1:
    y = x->CompanyVehicle;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompanyVehicle; n > 1 && y; --n, y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_CompanyVehicle) */

void zx_hrxml_Benefits_DEL_CompanyVehicle(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_CompanyVehicle_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompanyVehicle = (struct zx_hrxml_CompanyVehicle_s*)x->CompanyVehicle->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CompanyVehicle_s*)x->CompanyVehicle;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompanyVehicle; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompanyVehicle_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_RelocationAssistance) */

int zx_hrxml_Benefits_NUM_RelocationAssistance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RelocationAssistance; y; ++n, y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_RelocationAssistance) */

struct zx_hrxml_RelocationAssistance_s* zx_hrxml_Benefits_GET_RelocationAssistance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x) return 0;
  for (y = x->RelocationAssistance; n>=0 && y; --n, y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_RelocationAssistance) */

struct zx_hrxml_RelocationAssistance_s* zx_hrxml_Benefits_POP_RelocationAssistance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x) return 0;
  y = x->RelocationAssistance;
  if (y)
    x->RelocationAssistance = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_RelocationAssistance) */

void zx_hrxml_Benefits_PUSH_RelocationAssistance(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_RelocationAssistance_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RelocationAssistance->gg.g;
  x->RelocationAssistance = z;
}

/* FUNC(zx_hrxml_Benefits_REV_RelocationAssistance) */

void zx_hrxml_Benefits_REV_RelocationAssistance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_RelocationAssistance_s* nxt;
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x) return;
  y = x->RelocationAssistance;
  if (!y) return;
  x->RelocationAssistance = 0;
  while (y) {
    nxt = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n;
    y->gg.g.n = &x->RelocationAssistance->gg.g;
    x->RelocationAssistance = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_RelocationAssistance) */

void zx_hrxml_Benefits_PUT_RelocationAssistance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_RelocationAssistance_s* z)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x || !z) return;
  y = x->RelocationAssistance;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RelocationAssistance = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_RelocationAssistance) */

void zx_hrxml_Benefits_ADD_RelocationAssistance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_RelocationAssistance_s* z)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RelocationAssistance->gg.g;
    x->RelocationAssistance = z;
    return;
  case -1:
    y = x->RelocationAssistance;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelocationAssistance; n > 1 && y; --n, y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_RelocationAssistance) */

void zx_hrxml_Benefits_DEL_RelocationAssistance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_RelocationAssistance_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RelocationAssistance = (struct zx_hrxml_RelocationAssistance_s*)x->RelocationAssistance->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RelocationAssistance_s*)x->RelocationAssistance;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelocationAssistance; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelocationAssistance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_VisaSponsorship) */

int zx_hrxml_Benefits_NUM_VisaSponsorship(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->VisaSponsorship; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_VisaSponsorship) */

struct zx_elem_s* zx_hrxml_Benefits_GET_VisaSponsorship(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->VisaSponsorship; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_VisaSponsorship) */

struct zx_elem_s* zx_hrxml_Benefits_POP_VisaSponsorship(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->VisaSponsorship;
  if (y)
    x->VisaSponsorship = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_VisaSponsorship) */

void zx_hrxml_Benefits_PUSH_VisaSponsorship(struct zx_hrxml_Benefits_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->VisaSponsorship->g;
  x->VisaSponsorship = z;
}

/* FUNC(zx_hrxml_Benefits_REV_VisaSponsorship) */

void zx_hrxml_Benefits_REV_VisaSponsorship(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->VisaSponsorship;
  if (!y) return;
  x->VisaSponsorship = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->VisaSponsorship->g;
    x->VisaSponsorship = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_VisaSponsorship) */

void zx_hrxml_Benefits_PUT_VisaSponsorship(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->VisaSponsorship;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->VisaSponsorship = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_VisaSponsorship) */

void zx_hrxml_Benefits_ADD_VisaSponsorship(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->VisaSponsorship->g;
    x->VisaSponsorship = z;
    return;
  case -1:
    y = x->VisaSponsorship;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->VisaSponsorship; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Benefits_DEL_VisaSponsorship) */

void zx_hrxml_Benefits_DEL_VisaSponsorship(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->VisaSponsorship = (struct zx_elem_s*)x->VisaSponsorship->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->VisaSponsorship;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->VisaSponsorship; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_TimeOffAllowance) */

int zx_hrxml_Benefits_NUM_TimeOffAllowance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TimeOffAllowance; y; ++n, y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_TimeOffAllowance) */

struct zx_hrxml_TimeOffAllowance_s* zx_hrxml_Benefits_GET_TimeOffAllowance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x) return 0;
  for (y = x->TimeOffAllowance; n>=0 && y; --n, y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_TimeOffAllowance) */

struct zx_hrxml_TimeOffAllowance_s* zx_hrxml_Benefits_POP_TimeOffAllowance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x) return 0;
  y = x->TimeOffAllowance;
  if (y)
    x->TimeOffAllowance = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_TimeOffAllowance) */

void zx_hrxml_Benefits_PUSH_TimeOffAllowance(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_TimeOffAllowance_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TimeOffAllowance->gg.g;
  x->TimeOffAllowance = z;
}

/* FUNC(zx_hrxml_Benefits_REV_TimeOffAllowance) */

void zx_hrxml_Benefits_REV_TimeOffAllowance(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_TimeOffAllowance_s* nxt;
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x) return;
  y = x->TimeOffAllowance;
  if (!y) return;
  x->TimeOffAllowance = 0;
  while (y) {
    nxt = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n;
    y->gg.g.n = &x->TimeOffAllowance->gg.g;
    x->TimeOffAllowance = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_TimeOffAllowance) */

void zx_hrxml_Benefits_PUT_TimeOffAllowance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_TimeOffAllowance_s* z)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x || !z) return;
  y = x->TimeOffAllowance;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TimeOffAllowance = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_TimeOffAllowance) */

void zx_hrxml_Benefits_ADD_TimeOffAllowance(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_TimeOffAllowance_s* z)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TimeOffAllowance->gg.g;
    x->TimeOffAllowance = z;
    return;
  case -1:
    y = x->TimeOffAllowance;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TimeOffAllowance; n > 1 && y; --n, y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_TimeOffAllowance) */

void zx_hrxml_Benefits_DEL_TimeOffAllowance(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_TimeOffAllowance_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TimeOffAllowance = (struct zx_hrxml_TimeOffAllowance_s*)x->TimeOffAllowance->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TimeOffAllowance_s*)x->TimeOffAllowance;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TimeOffAllowance; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TimeOffAllowance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_ExpatriateBenefits) */

int zx_hrxml_Benefits_NUM_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ExpatriateBenefits; y; ++n, y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_ExpatriateBenefits) */

struct zx_hrxml_ExpatriateBenefits_s* zx_hrxml_Benefits_GET_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x) return 0;
  for (y = x->ExpatriateBenefits; n>=0 && y; --n, y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_ExpatriateBenefits) */

struct zx_hrxml_ExpatriateBenefits_s* zx_hrxml_Benefits_POP_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x) return 0;
  y = x->ExpatriateBenefits;
  if (y)
    x->ExpatriateBenefits = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_ExpatriateBenefits) */

void zx_hrxml_Benefits_PUSH_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_ExpatriateBenefits_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ExpatriateBenefits->gg.g;
  x->ExpatriateBenefits = z;
}

/* FUNC(zx_hrxml_Benefits_REV_ExpatriateBenefits) */

void zx_hrxml_Benefits_REV_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_ExpatriateBenefits_s* nxt;
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x) return;
  y = x->ExpatriateBenefits;
  if (!y) return;
  x->ExpatriateBenefits = 0;
  while (y) {
    nxt = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n;
    y->gg.g.n = &x->ExpatriateBenefits->gg.g;
    x->ExpatriateBenefits = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_ExpatriateBenefits) */

void zx_hrxml_Benefits_PUT_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_ExpatriateBenefits_s* z)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x || !z) return;
  y = x->ExpatriateBenefits;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ExpatriateBenefits = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_ExpatriateBenefits) */

void zx_hrxml_Benefits_ADD_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_ExpatriateBenefits_s* z)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ExpatriateBenefits->gg.g;
    x->ExpatriateBenefits = z;
    return;
  case -1:
    y = x->ExpatriateBenefits;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefits; n > 1 && y; --n, y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_ExpatriateBenefits) */

void zx_hrxml_Benefits_DEL_ExpatriateBenefits(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_ExpatriateBenefits_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ExpatriateBenefits = (struct zx_hrxml_ExpatriateBenefits_s*)x->ExpatriateBenefits->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ExpatriateBenefits_s*)x->ExpatriateBenefits;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefits; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ExpatriateBenefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_OtherBenefits) */

int zx_hrxml_Benefits_NUM_OtherBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_OtherBenefits_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherBenefits; y; ++n, y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_OtherBenefits) */

struct zx_hrxml_OtherBenefits_s* zx_hrxml_Benefits_GET_OtherBenefits(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x) return 0;
  for (y = x->OtherBenefits; n>=0 && y; --n, y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_OtherBenefits) */

struct zx_hrxml_OtherBenefits_s* zx_hrxml_Benefits_POP_OtherBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x) return 0;
  y = x->OtherBenefits;
  if (y)
    x->OtherBenefits = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_OtherBenefits) */

void zx_hrxml_Benefits_PUSH_OtherBenefits(struct zx_hrxml_Benefits_s* x, struct zx_hrxml_OtherBenefits_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherBenefits->gg.g;
  x->OtherBenefits = z;
}

/* FUNC(zx_hrxml_Benefits_REV_OtherBenefits) */

void zx_hrxml_Benefits_REV_OtherBenefits(struct zx_hrxml_Benefits_s* x)
{
  struct zx_hrxml_OtherBenefits_s* nxt;
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x) return;
  y = x->OtherBenefits;
  if (!y) return;
  x->OtherBenefits = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherBenefits->gg.g;
    x->OtherBenefits = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_OtherBenefits) */

void zx_hrxml_Benefits_PUT_OtherBenefits(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_OtherBenefits_s* z)
{
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x || !z) return;
  y = x->OtherBenefits;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherBenefits = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_OtherBenefits) */

void zx_hrxml_Benefits_ADD_OtherBenefits(struct zx_hrxml_Benefits_s* x, int n, struct zx_hrxml_OtherBenefits_s* z)
{
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherBenefits->gg.g;
    x->OtherBenefits = z;
    return;
  case -1:
    y = x->OtherBenefits;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherBenefits; n > 1 && y; --n, y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Benefits_DEL_OtherBenefits) */

void zx_hrxml_Benefits_DEL_OtherBenefits(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_hrxml_OtherBenefits_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherBenefits = (struct zx_hrxml_OtherBenefits_s*)x->OtherBenefits->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherBenefits_s*)x->OtherBenefits;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherBenefits; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherBenefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Benefits_NUM_Comments) */

int zx_hrxml_Benefits_NUM_Comments(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Benefits_GET_Comments) */

struct zx_elem_s* zx_hrxml_Benefits_GET_Comments(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Benefits_POP_Comments) */

struct zx_elem_s* zx_hrxml_Benefits_POP_Comments(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Benefits_PUSH_Comments) */

void zx_hrxml_Benefits_PUSH_Comments(struct zx_hrxml_Benefits_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Benefits_REV_Comments) */

void zx_hrxml_Benefits_REV_Comments(struct zx_hrxml_Benefits_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Benefits_PUT_Comments) */

void zx_hrxml_Benefits_PUT_Comments(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Benefits_ADD_Comments) */

void zx_hrxml_Benefits_ADD_Comments(struct zx_hrxml_Benefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Benefits_DEL_Comments) */

void zx_hrxml_Benefits_DEL_Comments(struct zx_hrxml_Benefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_DateOfBirth) */

int zx_hrxml_BiologicalDescriptors_NUM_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DateOfBirth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_DateOfBirth) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DateOfBirth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_DateOfBirth) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DateOfBirth;
  if (y)
    x->DateOfBirth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_DateOfBirth) */

void zx_hrxml_BiologicalDescriptors_PUSH_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DateOfBirth->g;
  x->DateOfBirth = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_DateOfBirth) */

void zx_hrxml_BiologicalDescriptors_REV_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DateOfBirth;
  if (!y) return;
  x->DateOfBirth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DateOfBirth->g;
    x->DateOfBirth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_DateOfBirth) */

void zx_hrxml_BiologicalDescriptors_PUT_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DateOfBirth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DateOfBirth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_DateOfBirth) */

void zx_hrxml_BiologicalDescriptors_ADD_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DateOfBirth->g;
    x->DateOfBirth = z;
    return;
  case -1:
    y = x->DateOfBirth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DateOfBirth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_DateOfBirth) */

void zx_hrxml_BiologicalDescriptors_DEL_DateOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DateOfBirth = (struct zx_elem_s*)x->DateOfBirth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DateOfBirth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DateOfBirth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_MonthDayOfBirth) */

int zx_hrxml_BiologicalDescriptors_NUM_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDayOfBirth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_MonthDayOfBirth) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDayOfBirth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_MonthDayOfBirth) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDayOfBirth;
  if (y)
    x->MonthDayOfBirth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_MonthDayOfBirth) */

void zx_hrxml_BiologicalDescriptors_PUSH_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDayOfBirth->g;
  x->MonthDayOfBirth = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_MonthDayOfBirth) */

void zx_hrxml_BiologicalDescriptors_REV_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDayOfBirth;
  if (!y) return;
  x->MonthDayOfBirth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDayOfBirth->g;
    x->MonthDayOfBirth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_MonthDayOfBirth) */

void zx_hrxml_BiologicalDescriptors_PUT_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDayOfBirth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDayOfBirth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_MonthDayOfBirth) */

void zx_hrxml_BiologicalDescriptors_ADD_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDayOfBirth->g;
    x->MonthDayOfBirth = z;
    return;
  case -1:
    y = x->MonthDayOfBirth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDayOfBirth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_MonthDayOfBirth) */

void zx_hrxml_BiologicalDescriptors_DEL_MonthDayOfBirth(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDayOfBirth = (struct zx_elem_s*)x->MonthDayOfBirth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDayOfBirth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDayOfBirth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_Age) */

int zx_hrxml_BiologicalDescriptors_NUM_Age(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Age; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_Age) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_Age(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Age; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_Age) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_Age(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Age;
  if (y)
    x->Age = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_Age) */

void zx_hrxml_BiologicalDescriptors_PUSH_Age(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Age->g;
  x->Age = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_Age) */

void zx_hrxml_BiologicalDescriptors_REV_Age(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Age;
  if (!y) return;
  x->Age = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Age->g;
    x->Age = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_Age) */

void zx_hrxml_BiologicalDescriptors_PUT_Age(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Age;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Age = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_Age) */

void zx_hrxml_BiologicalDescriptors_ADD_Age(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Age->g;
    x->Age = z;
    return;
  case -1:
    y = x->Age;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Age; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_Age) */

void zx_hrxml_BiologicalDescriptors_DEL_Age(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Age = (struct zx_elem_s*)x->Age->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Age;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Age; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_GenderCode) */

int zx_hrxml_BiologicalDescriptors_NUM_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->GenderCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_GenderCode) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->GenderCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_GenderCode) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->GenderCode;
  if (y)
    x->GenderCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_GenderCode) */

void zx_hrxml_BiologicalDescriptors_PUSH_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->GenderCode->g;
  x->GenderCode = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_GenderCode) */

void zx_hrxml_BiologicalDescriptors_REV_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->GenderCode;
  if (!y) return;
  x->GenderCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->GenderCode->g;
    x->GenderCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_GenderCode) */

void zx_hrxml_BiologicalDescriptors_PUT_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->GenderCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->GenderCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_GenderCode) */

void zx_hrxml_BiologicalDescriptors_ADD_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->GenderCode->g;
    x->GenderCode = z;
    return;
  case -1:
    y = x->GenderCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GenderCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_GenderCode) */

void zx_hrxml_BiologicalDescriptors_DEL_GenderCode(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->GenderCode = (struct zx_elem_s*)x->GenderCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->GenderCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GenderCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_EyeColor) */

int zx_hrxml_BiologicalDescriptors_NUM_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EyeColor; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_EyeColor) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EyeColor; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_EyeColor) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EyeColor;
  if (y)
    x->EyeColor = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_EyeColor) */

void zx_hrxml_BiologicalDescriptors_PUSH_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EyeColor->g;
  x->EyeColor = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_EyeColor) */

void zx_hrxml_BiologicalDescriptors_REV_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EyeColor;
  if (!y) return;
  x->EyeColor = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EyeColor->g;
    x->EyeColor = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_EyeColor) */

void zx_hrxml_BiologicalDescriptors_PUT_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EyeColor;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EyeColor = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_EyeColor) */

void zx_hrxml_BiologicalDescriptors_ADD_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EyeColor->g;
    x->EyeColor = z;
    return;
  case -1:
    y = x->EyeColor;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EyeColor; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_EyeColor) */

void zx_hrxml_BiologicalDescriptors_DEL_EyeColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EyeColor = (struct zx_elem_s*)x->EyeColor->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EyeColor;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EyeColor; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_HairColor) */

int zx_hrxml_BiologicalDescriptors_NUM_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->HairColor; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_HairColor) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->HairColor; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_HairColor) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->HairColor;
  if (y)
    x->HairColor = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_HairColor) */

void zx_hrxml_BiologicalDescriptors_PUSH_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->HairColor->g;
  x->HairColor = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_HairColor) */

void zx_hrxml_BiologicalDescriptors_REV_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->HairColor;
  if (!y) return;
  x->HairColor = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->HairColor->g;
    x->HairColor = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_HairColor) */

void zx_hrxml_BiologicalDescriptors_PUT_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->HairColor;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->HairColor = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_HairColor) */

void zx_hrxml_BiologicalDescriptors_ADD_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->HairColor->g;
    x->HairColor = z;
    return;
  case -1:
    y = x->HairColor;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->HairColor; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_HairColor) */

void zx_hrxml_BiologicalDescriptors_DEL_HairColor(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->HairColor = (struct zx_elem_s*)x->HairColor->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->HairColor;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->HairColor; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_Height) */

int zx_hrxml_BiologicalDescriptors_NUM_Height(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Height_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Height; y; ++n, y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_Height) */

struct zx_hrxml_Height_s* zx_hrxml_BiologicalDescriptors_GET_Height(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_Height_s* y;
  if (!x) return 0;
  for (y = x->Height; n>=0 && y; --n, y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_Height) */

struct zx_hrxml_Height_s* zx_hrxml_BiologicalDescriptors_POP_Height(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Height_s* y;
  if (!x) return 0;
  y = x->Height;
  if (y)
    x->Height = (struct zx_hrxml_Height_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_Height) */

void zx_hrxml_BiologicalDescriptors_PUSH_Height(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_hrxml_Height_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Height->gg.g;
  x->Height = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_Height) */

void zx_hrxml_BiologicalDescriptors_REV_Height(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Height_s* nxt;
  struct zx_hrxml_Height_s* y;
  if (!x) return;
  y = x->Height;
  if (!y) return;
  x->Height = 0;
  while (y) {
    nxt = (struct zx_hrxml_Height_s*)y->gg.g.n;
    y->gg.g.n = &x->Height->gg.g;
    x->Height = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_Height) */

void zx_hrxml_BiologicalDescriptors_PUT_Height(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_Height_s* z)
{
  struct zx_hrxml_Height_s* y;
  if (!x || !z) return;
  y = x->Height;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Height = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_Height) */

void zx_hrxml_BiologicalDescriptors_ADD_Height(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_Height_s* z)
{
  struct zx_hrxml_Height_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Height->gg.g;
    x->Height = z;
    return;
  case -1:
    y = x->Height;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Height; n > 1 && y; --n, y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_Height) */

void zx_hrxml_BiologicalDescriptors_DEL_Height(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_Height_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Height = (struct zx_hrxml_Height_s*)x->Height->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Height_s*)x->Height;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Height; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Height_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_Weight) */

int zx_hrxml_BiologicalDescriptors_NUM_Weight(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Weight_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Weight; y; ++n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_BiologicalDescriptors_GET_Weight(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  for (y = x->Weight; n>=0 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_BiologicalDescriptors_POP_Weight(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  y = x->Weight;
  if (y)
    x->Weight = (struct zx_hrxml_Weight_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_Weight) */

void zx_hrxml_BiologicalDescriptors_PUSH_Weight(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_hrxml_Weight_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Weight->gg.g;
  x->Weight = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_Weight) */

void zx_hrxml_BiologicalDescriptors_REV_Weight(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_Weight_s* nxt;
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  y = x->Weight;
  if (!y) return;
  x->Weight = 0;
  while (y) {
    nxt = (struct zx_hrxml_Weight_s*)y->gg.g.n;
    y->gg.g.n = &x->Weight->gg.g;
    x->Weight = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_Weight) */

void zx_hrxml_BiologicalDescriptors_PUT_Weight(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  y = x->Weight;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Weight = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_Weight) */

void zx_hrxml_BiologicalDescriptors_ADD_Weight(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Weight->gg.g;
    x->Weight = z;
    return;
  case -1:
    y = x->Weight;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_Weight) */

void zx_hrxml_BiologicalDescriptors_DEL_Weight(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Weight = (struct zx_hrxml_Weight_s*)x->Weight->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Weight_s*)x->Weight;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_IdentifyingMarks) */

int zx_hrxml_BiologicalDescriptors_NUM_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdentifyingMarks; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_IdentifyingMarks) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_GET_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->IdentifyingMarks; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_IdentifyingMarks) */

struct zx_elem_s* zx_hrxml_BiologicalDescriptors_POP_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->IdentifyingMarks;
  if (y)
    x->IdentifyingMarks = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_IdentifyingMarks) */

void zx_hrxml_BiologicalDescriptors_PUSH_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->IdentifyingMarks->g;
  x->IdentifyingMarks = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_IdentifyingMarks) */

void zx_hrxml_BiologicalDescriptors_REV_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->IdentifyingMarks;
  if (!y) return;
  x->IdentifyingMarks = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->IdentifyingMarks->g;
    x->IdentifyingMarks = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_IdentifyingMarks) */

void zx_hrxml_BiologicalDescriptors_PUT_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->IdentifyingMarks;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->IdentifyingMarks = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_IdentifyingMarks) */

void zx_hrxml_BiologicalDescriptors_ADD_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->IdentifyingMarks->g;
    x->IdentifyingMarks = z;
    return;
  case -1:
    y = x->IdentifyingMarks;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IdentifyingMarks; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_IdentifyingMarks) */

void zx_hrxml_BiologicalDescriptors_DEL_IdentifyingMarks(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdentifyingMarks = (struct zx_elem_s*)x->IdentifyingMarks->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->IdentifyingMarks;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IdentifyingMarks; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_DisabilityInfo) */

int zx_hrxml_BiologicalDescriptors_NUM_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DisabilityInfo; y; ++n, y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_DisabilityInfo) */

struct zx_hrxml_DisabilityInfo_s* zx_hrxml_BiologicalDescriptors_GET_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x) return 0;
  for (y = x->DisabilityInfo; n>=0 && y; --n, y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_DisabilityInfo) */

struct zx_hrxml_DisabilityInfo_s* zx_hrxml_BiologicalDescriptors_POP_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x) return 0;
  y = x->DisabilityInfo;
  if (y)
    x->DisabilityInfo = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_DisabilityInfo) */

void zx_hrxml_BiologicalDescriptors_PUSH_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_hrxml_DisabilityInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DisabilityInfo->gg.g;
  x->DisabilityInfo = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_DisabilityInfo) */

void zx_hrxml_BiologicalDescriptors_REV_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_DisabilityInfo_s* nxt;
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x) return;
  y = x->DisabilityInfo;
  if (!y) return;
  x->DisabilityInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->DisabilityInfo->gg.g;
    x->DisabilityInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_DisabilityInfo) */

void zx_hrxml_BiologicalDescriptors_PUT_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_DisabilityInfo_s* z)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x || !z) return;
  y = x->DisabilityInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DisabilityInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_DisabilityInfo) */

void zx_hrxml_BiologicalDescriptors_ADD_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_DisabilityInfo_s* z)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DisabilityInfo->gg.g;
    x->DisabilityInfo = z;
    return;
  case -1:
    y = x->DisabilityInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DisabilityInfo; n > 1 && y; --n, y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_DisabilityInfo) */

void zx_hrxml_BiologicalDescriptors_DEL_DisabilityInfo(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_DisabilityInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DisabilityInfo = (struct zx_hrxml_DisabilityInfo_s*)x->DisabilityInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DisabilityInfo_s*)x->DisabilityInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DisabilityInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DisabilityInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_BiologicalDescriptors_NUM_UserArea) */

int zx_hrxml_BiologicalDescriptors_NUM_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_BiologicalDescriptors_GET_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_BiologicalDescriptors_POP_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUSH_UserArea) */

void zx_hrxml_BiologicalDescriptors_PUSH_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_REV_UserArea) */

void zx_hrxml_BiologicalDescriptors_REV_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_PUT_UserArea) */

void zx_hrxml_BiologicalDescriptors_PUT_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_BiologicalDescriptors_ADD_UserArea) */

void zx_hrxml_BiologicalDescriptors_ADD_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_BiologicalDescriptors_DEL_UserArea) */

void zx_hrxml_BiologicalDescriptors_DEL_UserArea(struct zx_hrxml_BiologicalDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Title) */

int zx_hrxml_Book_NUM_Title(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Title) */

struct zx_elem_s* zx_hrxml_Book_GET_Title(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Title) */

struct zx_elem_s* zx_hrxml_Book_POP_Title(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Title) */

void zx_hrxml_Book_PUSH_Title(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_Book_REV_Title) */

void zx_hrxml_Book_REV_Title(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Title) */

void zx_hrxml_Book_PUT_Title(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Title) */

void zx_hrxml_Book_ADD_Title(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Title) */

void zx_hrxml_Book_DEL_Title(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Name) */

int zx_hrxml_Book_NUM_Name(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Name) */

struct zx_elem_s* zx_hrxml_Book_GET_Name(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Name) */

struct zx_elem_s* zx_hrxml_Book_POP_Name(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Name) */

void zx_hrxml_Book_PUSH_Name(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_Book_REV_Name) */

void zx_hrxml_Book_REV_Name(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Name) */

void zx_hrxml_Book_PUT_Name(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Name) */

void zx_hrxml_Book_ADD_Name(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Name) */

void zx_hrxml_Book_DEL_Name(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_PublicationDate) */

int zx_hrxml_Book_NUM_PublicationDate(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationDate; y; ++n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_Book_GET_PublicationDate(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  for (y = x->PublicationDate; n>=0 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_Book_POP_PublicationDate(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  y = x->PublicationDate;
  if (y)
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_PublicationDate) */

void zx_hrxml_Book_PUSH_PublicationDate(struct zx_hrxml_Book_s* x, struct zx_hrxml_PublicationDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationDate->gg.g;
  x->PublicationDate = z;
}

/* FUNC(zx_hrxml_Book_REV_PublicationDate) */

void zx_hrxml_Book_REV_PublicationDate(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_PublicationDate_s* nxt;
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  y = x->PublicationDate;
  if (!y) return;
  x->PublicationDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_PublicationDate) */

void zx_hrxml_Book_PUT_PublicationDate(struct zx_hrxml_Book_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  y = x->PublicationDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_PublicationDate) */

void zx_hrxml_Book_ADD_PublicationDate(struct zx_hrxml_Book_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = z;
    return;
  case -1:
    y = x->PublicationDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Book_DEL_PublicationDate) */

void zx_hrxml_Book_DEL_PublicationDate(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Link) */

int zx_hrxml_Book_NUM_Link(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Link) */

struct zx_elem_s* zx_hrxml_Book_GET_Link(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Link) */

struct zx_elem_s* zx_hrxml_Book_POP_Link(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Link) */

void zx_hrxml_Book_PUSH_Link(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_Book_REV_Link) */

void zx_hrxml_Book_REV_Link(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Link) */

void zx_hrxml_Book_PUT_Link(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Link) */

void zx_hrxml_Book_ADD_Link(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Link) */

void zx_hrxml_Book_DEL_Link(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Abstract) */

int zx_hrxml_Book_NUM_Abstract(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Abstract; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Abstract) */

struct zx_elem_s* zx_hrxml_Book_GET_Abstract(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Abstract; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Abstract) */

struct zx_elem_s* zx_hrxml_Book_POP_Abstract(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Abstract;
  if (y)
    x->Abstract = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Abstract) */

void zx_hrxml_Book_PUSH_Abstract(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Abstract->g;
  x->Abstract = z;
}

/* FUNC(zx_hrxml_Book_REV_Abstract) */

void zx_hrxml_Book_REV_Abstract(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Abstract;
  if (!y) return;
  x->Abstract = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Abstract->g;
    x->Abstract = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Abstract) */

void zx_hrxml_Book_PUT_Abstract(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Abstract;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Abstract = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Abstract) */

void zx_hrxml_Book_ADD_Abstract(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Abstract->g;
    x->Abstract = z;
    return;
  case -1:
    y = x->Abstract;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Abstract) */

void zx_hrxml_Book_DEL_Abstract(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Abstract = (struct zx_elem_s*)x->Abstract->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Abstract;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Copyright) */

int zx_hrxml_Book_NUM_Copyright(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Copyright; y; ++n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_Book_GET_Copyright(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  for (y = x->Copyright; n>=0 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_Book_POP_Copyright(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  y = x->Copyright;
  if (y)
    x->Copyright = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Copyright) */

void zx_hrxml_Book_PUSH_Copyright(struct zx_hrxml_Book_s* x, struct zx_hrxml_Copyright_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Copyright->gg.g;
  x->Copyright = z;
}

/* FUNC(zx_hrxml_Book_REV_Copyright) */

void zx_hrxml_Book_REV_Copyright(struct zx_hrxml_Book_s* x)
{
  struct zx_hrxml_Copyright_s* nxt;
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  y = x->Copyright;
  if (!y) return;
  x->Copyright = 0;
  while (y) {
    nxt = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
    y->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Copyright) */

void zx_hrxml_Book_PUT_Copyright(struct zx_hrxml_Book_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  y = x->Copyright;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Copyright = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Copyright) */

void zx_hrxml_Book_ADD_Copyright(struct zx_hrxml_Book_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = z;
    return;
  case -1:
    y = x->Copyright;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Book_DEL_Copyright) */

void zx_hrxml_Book_DEL_Copyright(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Copyright = (struct zx_hrxml_Copyright_s*)x->Copyright->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Copyright_s*)x->Copyright;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Comments) */

int zx_hrxml_Book_NUM_Comments(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Comments) */

struct zx_elem_s* zx_hrxml_Book_GET_Comments(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Comments) */

struct zx_elem_s* zx_hrxml_Book_POP_Comments(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Comments) */

void zx_hrxml_Book_PUSH_Comments(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Book_REV_Comments) */

void zx_hrxml_Book_REV_Comments(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Comments) */

void zx_hrxml_Book_PUT_Comments(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Comments) */

void zx_hrxml_Book_ADD_Comments(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Comments) */

void zx_hrxml_Book_DEL_Comments(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Edition) */

int zx_hrxml_Book_NUM_Edition(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Edition; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Edition) */

struct zx_elem_s* zx_hrxml_Book_GET_Edition(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Edition; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Edition) */

struct zx_elem_s* zx_hrxml_Book_POP_Edition(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Edition;
  if (y)
    x->Edition = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Edition) */

void zx_hrxml_Book_PUSH_Edition(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Edition->g;
  x->Edition = z;
}

/* FUNC(zx_hrxml_Book_REV_Edition) */

void zx_hrxml_Book_REV_Edition(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Edition;
  if (!y) return;
  x->Edition = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Edition->g;
    x->Edition = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Edition) */

void zx_hrxml_Book_PUT_Edition(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Edition;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Edition = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Edition) */

void zx_hrxml_Book_ADD_Edition(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Edition->g;
    x->Edition = z;
    return;
  case -1:
    y = x->Edition;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Edition; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Edition) */

void zx_hrxml_Book_DEL_Edition(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Edition = (struct zx_elem_s*)x->Edition->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Edition;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Edition; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_Chapter) */

int zx_hrxml_Book_NUM_Chapter(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Chapter; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_Chapter) */

struct zx_elem_s* zx_hrxml_Book_GET_Chapter(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Chapter; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_Chapter) */

struct zx_elem_s* zx_hrxml_Book_POP_Chapter(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Chapter;
  if (y)
    x->Chapter = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_Chapter) */

void zx_hrxml_Book_PUSH_Chapter(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Chapter->g;
  x->Chapter = z;
}

/* FUNC(zx_hrxml_Book_REV_Chapter) */

void zx_hrxml_Book_REV_Chapter(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Chapter;
  if (!y) return;
  x->Chapter = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Chapter->g;
    x->Chapter = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_Chapter) */

void zx_hrxml_Book_PUT_Chapter(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Chapter;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Chapter = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_Chapter) */

void zx_hrxml_Book_ADD_Chapter(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Chapter->g;
    x->Chapter = z;
    return;
  case -1:
    y = x->Chapter;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Chapter; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_Chapter) */

void zx_hrxml_Book_DEL_Chapter(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Chapter = (struct zx_elem_s*)x->Chapter->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Chapter;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Chapter; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_ISSN) */

int zx_hrxml_Book_NUM_ISSN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISSN; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_ISSN) */

struct zx_elem_s* zx_hrxml_Book_GET_ISSN(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISSN; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_ISSN) */

struct zx_elem_s* zx_hrxml_Book_POP_ISSN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISSN;
  if (y)
    x->ISSN = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_ISSN) */

void zx_hrxml_Book_PUSH_ISSN(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISSN->g;
  x->ISSN = z;
}

/* FUNC(zx_hrxml_Book_REV_ISSN) */

void zx_hrxml_Book_REV_ISSN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISSN;
  if (!y) return;
  x->ISSN = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISSN->g;
    x->ISSN = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_ISSN) */

void zx_hrxml_Book_PUT_ISSN(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISSN;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISSN = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_ISSN) */

void zx_hrxml_Book_ADD_ISSN(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISSN->g;
    x->ISSN = z;
    return;
  case -1:
    y = x->ISSN;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_ISSN) */

void zx_hrxml_Book_DEL_ISSN(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISSN = (struct zx_elem_s*)x->ISSN->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISSN;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_ISBN) */

int zx_hrxml_Book_NUM_ISBN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISBN; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_ISBN) */

struct zx_elem_s* zx_hrxml_Book_GET_ISBN(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISBN; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_ISBN) */

struct zx_elem_s* zx_hrxml_Book_POP_ISBN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISBN;
  if (y)
    x->ISBN = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_ISBN) */

void zx_hrxml_Book_PUSH_ISBN(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISBN->g;
  x->ISBN = z;
}

/* FUNC(zx_hrxml_Book_REV_ISBN) */

void zx_hrxml_Book_REV_ISBN(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISBN;
  if (!y) return;
  x->ISBN = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISBN->g;
    x->ISBN = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_ISBN) */

void zx_hrxml_Book_PUT_ISBN(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISBN;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISBN = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_ISBN) */

void zx_hrxml_Book_ADD_ISBN(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISBN->g;
    x->ISBN = z;
    return;
  case -1:
    y = x->ISBN;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISBN; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_ISBN) */

void zx_hrxml_Book_DEL_ISBN(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISBN = (struct zx_elem_s*)x->ISBN->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISBN;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISBN; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_NumberOfPages) */

int zx_hrxml_Book_NUM_NumberOfPages(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumberOfPages; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_NumberOfPages) */

struct zx_elem_s* zx_hrxml_Book_GET_NumberOfPages(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->NumberOfPages; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_NumberOfPages) */

struct zx_elem_s* zx_hrxml_Book_POP_NumberOfPages(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->NumberOfPages;
  if (y)
    x->NumberOfPages = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_NumberOfPages) */

void zx_hrxml_Book_PUSH_NumberOfPages(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->NumberOfPages->g;
  x->NumberOfPages = z;
}

/* FUNC(zx_hrxml_Book_REV_NumberOfPages) */

void zx_hrxml_Book_REV_NumberOfPages(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->NumberOfPages;
  if (!y) return;
  x->NumberOfPages = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->NumberOfPages->g;
    x->NumberOfPages = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_NumberOfPages) */

void zx_hrxml_Book_PUT_NumberOfPages(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->NumberOfPages;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->NumberOfPages = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_NumberOfPages) */

void zx_hrxml_Book_ADD_NumberOfPages(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->NumberOfPages->g;
    x->NumberOfPages = z;
    return;
  case -1:
    y = x->NumberOfPages;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfPages; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_NumberOfPages) */

void zx_hrxml_Book_DEL_NumberOfPages(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumberOfPages = (struct zx_elem_s*)x->NumberOfPages->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->NumberOfPages;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfPages; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_PublisherName) */

int zx_hrxml_Book_NUM_PublisherName(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublisherName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_PublisherName) */

struct zx_elem_s* zx_hrxml_Book_GET_PublisherName(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PublisherName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_PublisherName) */

struct zx_elem_s* zx_hrxml_Book_POP_PublisherName(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PublisherName;
  if (y)
    x->PublisherName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_PublisherName) */

void zx_hrxml_Book_PUSH_PublisherName(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PublisherName->g;
  x->PublisherName = z;
}

/* FUNC(zx_hrxml_Book_REV_PublisherName) */

void zx_hrxml_Book_REV_PublisherName(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PublisherName;
  if (!y) return;
  x->PublisherName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PublisherName->g;
    x->PublisherName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_PublisherName) */

void zx_hrxml_Book_PUT_PublisherName(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PublisherName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PublisherName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_PublisherName) */

void zx_hrxml_Book_ADD_PublisherName(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PublisherName->g;
    x->PublisherName = z;
    return;
  case -1:
    y = x->PublisherName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_PublisherName) */

void zx_hrxml_Book_DEL_PublisherName(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublisherName = (struct zx_elem_s*)x->PublisherName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PublisherName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Book_NUM_PublisherLocation) */

int zx_hrxml_Book_NUM_PublisherLocation(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublisherLocation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Book_GET_PublisherLocation) */

struct zx_elem_s* zx_hrxml_Book_GET_PublisherLocation(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PublisherLocation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Book_POP_PublisherLocation) */

struct zx_elem_s* zx_hrxml_Book_POP_PublisherLocation(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PublisherLocation;
  if (y)
    x->PublisherLocation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Book_PUSH_PublisherLocation) */

void zx_hrxml_Book_PUSH_PublisherLocation(struct zx_hrxml_Book_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PublisherLocation->g;
  x->PublisherLocation = z;
}

/* FUNC(zx_hrxml_Book_REV_PublisherLocation) */

void zx_hrxml_Book_REV_PublisherLocation(struct zx_hrxml_Book_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PublisherLocation;
  if (!y) return;
  x->PublisherLocation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PublisherLocation->g;
    x->PublisherLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Book_PUT_PublisherLocation) */

void zx_hrxml_Book_PUT_PublisherLocation(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PublisherLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PublisherLocation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Book_ADD_PublisherLocation) */

void zx_hrxml_Book_ADD_PublisherLocation(struct zx_hrxml_Book_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PublisherLocation->g;
    x->PublisherLocation = z;
    return;
  case -1:
    y = x->PublisherLocation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherLocation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Book_DEL_PublisherLocation) */

void zx_hrxml_Book_DEL_PublisherLocation(struct zx_hrxml_Book_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublisherLocation = (struct zx_elem_s*)x->PublisherLocation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PublisherLocation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherLocation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_CandidateRecordInfo) */

int zx_hrxml_Candidate_NUM_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CandidateRecordInfo; y; ++n, y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_CandidateRecordInfo) */

struct zx_hrxml_CandidateRecordInfo_s* zx_hrxml_Candidate_GET_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x) return 0;
  for (y = x->CandidateRecordInfo; n>=0 && y; --n, y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_CandidateRecordInfo) */

struct zx_hrxml_CandidateRecordInfo_s* zx_hrxml_Candidate_POP_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x) return 0;
  y = x->CandidateRecordInfo;
  if (y)
    x->CandidateRecordInfo = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_CandidateRecordInfo) */

void zx_hrxml_Candidate_PUSH_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_CandidateRecordInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CandidateRecordInfo->gg.g;
  x->CandidateRecordInfo = z;
}

/* FUNC(zx_hrxml_Candidate_REV_CandidateRecordInfo) */

void zx_hrxml_Candidate_REV_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateRecordInfo_s* nxt;
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x) return;
  y = x->CandidateRecordInfo;
  if (!y) return;
  x->CandidateRecordInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->CandidateRecordInfo->gg.g;
    x->CandidateRecordInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_CandidateRecordInfo) */

void zx_hrxml_Candidate_PUT_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateRecordInfo_s* z)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x || !z) return;
  y = x->CandidateRecordInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CandidateRecordInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_CandidateRecordInfo) */

void zx_hrxml_Candidate_ADD_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateRecordInfo_s* z)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CandidateRecordInfo->gg.g;
    x->CandidateRecordInfo = z;
    return;
  case -1:
    y = x->CandidateRecordInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateRecordInfo; n > 1 && y; --n, y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_CandidateRecordInfo) */

void zx_hrxml_Candidate_DEL_CandidateRecordInfo(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateRecordInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CandidateRecordInfo = (struct zx_hrxml_CandidateRecordInfo_s*)x->CandidateRecordInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CandidateRecordInfo_s*)x->CandidateRecordInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateRecordInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateRecordInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_RelatedPositionPostings) */

int zx_hrxml_Candidate_NUM_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RelatedPositionPostings; y; ++n, y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_RelatedPositionPostings) */

struct zx_hrxml_RelatedPositionPostings_s* zx_hrxml_Candidate_GET_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x) return 0;
  for (y = x->RelatedPositionPostings; n>=0 && y; --n, y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_RelatedPositionPostings) */

struct zx_hrxml_RelatedPositionPostings_s* zx_hrxml_Candidate_POP_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x) return 0;
  y = x->RelatedPositionPostings;
  if (y)
    x->RelatedPositionPostings = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_RelatedPositionPostings) */

void zx_hrxml_Candidate_PUSH_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_RelatedPositionPostings_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RelatedPositionPostings->gg.g;
  x->RelatedPositionPostings = z;
}

/* FUNC(zx_hrxml_Candidate_REV_RelatedPositionPostings) */

void zx_hrxml_Candidate_REV_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_RelatedPositionPostings_s* nxt;
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x) return;
  y = x->RelatedPositionPostings;
  if (!y) return;
  x->RelatedPositionPostings = 0;
  while (y) {
    nxt = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n;
    y->gg.g.n = &x->RelatedPositionPostings->gg.g;
    x->RelatedPositionPostings = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_RelatedPositionPostings) */

void zx_hrxml_Candidate_PUT_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_RelatedPositionPostings_s* z)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x || !z) return;
  y = x->RelatedPositionPostings;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RelatedPositionPostings = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_RelatedPositionPostings) */

void zx_hrxml_Candidate_ADD_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_RelatedPositionPostings_s* z)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RelatedPositionPostings->gg.g;
    x->RelatedPositionPostings = z;
    return;
  case -1:
    y = x->RelatedPositionPostings;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedPositionPostings; n > 1 && y; --n, y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_RelatedPositionPostings) */

void zx_hrxml_Candidate_DEL_RelatedPositionPostings(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_RelatedPositionPostings_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RelatedPositionPostings = (struct zx_hrxml_RelatedPositionPostings_s*)x->RelatedPositionPostings->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RelatedPositionPostings_s*)x->RelatedPositionPostings;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedPositionPostings; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedPositionPostings_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_CandidateSupplier) */

int zx_hrxml_Candidate_NUM_CandidateSupplier(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CandidateSupplier; y; ++n, y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_CandidateSupplier) */

struct zx_hrxml_CandidateSupplier_s* zx_hrxml_Candidate_GET_CandidateSupplier(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x) return 0;
  for (y = x->CandidateSupplier; n>=0 && y; --n, y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_CandidateSupplier) */

struct zx_hrxml_CandidateSupplier_s* zx_hrxml_Candidate_POP_CandidateSupplier(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x) return 0;
  y = x->CandidateSupplier;
  if (y)
    x->CandidateSupplier = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_CandidateSupplier) */

void zx_hrxml_Candidate_PUSH_CandidateSupplier(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_CandidateSupplier_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CandidateSupplier->gg.g;
  x->CandidateSupplier = z;
}

/* FUNC(zx_hrxml_Candidate_REV_CandidateSupplier) */

void zx_hrxml_Candidate_REV_CandidateSupplier(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateSupplier_s* nxt;
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x) return;
  y = x->CandidateSupplier;
  if (!y) return;
  x->CandidateSupplier = 0;
  while (y) {
    nxt = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n;
    y->gg.g.n = &x->CandidateSupplier->gg.g;
    x->CandidateSupplier = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_CandidateSupplier) */

void zx_hrxml_Candidate_PUT_CandidateSupplier(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateSupplier_s* z)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x || !z) return;
  y = x->CandidateSupplier;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CandidateSupplier = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_CandidateSupplier) */

void zx_hrxml_Candidate_ADD_CandidateSupplier(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateSupplier_s* z)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CandidateSupplier->gg.g;
    x->CandidateSupplier = z;
    return;
  case -1:
    y = x->CandidateSupplier;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateSupplier; n > 1 && y; --n, y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_CandidateSupplier) */

void zx_hrxml_Candidate_DEL_CandidateSupplier(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateSupplier_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CandidateSupplier = (struct zx_hrxml_CandidateSupplier_s*)x->CandidateSupplier->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CandidateSupplier_s*)x->CandidateSupplier;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateSupplier; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateSupplier_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_DistributionGuidelines) */

int zx_hrxml_Candidate_NUM_DistributionGuidelines(struct zx_hrxml_Candidate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_Candidate_GET_DistributionGuidelines(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_Candidate_POP_DistributionGuidelines(struct zx_hrxml_Candidate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DistributionGuidelines;
  if (y)
    x->DistributionGuidelines = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_DistributionGuidelines) */

void zx_hrxml_Candidate_PUSH_DistributionGuidelines(struct zx_hrxml_Candidate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DistributionGuidelines->g;
  x->DistributionGuidelines = z;
}

/* FUNC(zx_hrxml_Candidate_REV_DistributionGuidelines) */

void zx_hrxml_Candidate_REV_DistributionGuidelines(struct zx_hrxml_Candidate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  x->DistributionGuidelines = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_DistributionGuidelines) */

void zx_hrxml_Candidate_PUT_DistributionGuidelines(struct zx_hrxml_Candidate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DistributionGuidelines = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_DistributionGuidelines) */

void zx_hrxml_Candidate_ADD_DistributionGuidelines(struct zx_hrxml_Candidate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = z;
    return;
  case -1:
    y = x->DistributionGuidelines;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Candidate_DEL_DistributionGuidelines) */

void zx_hrxml_Candidate_DEL_DistributionGuidelines(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DistributionGuidelines = (struct zx_elem_s*)x->DistributionGuidelines->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DistributionGuidelines;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_CandidateProfile) */

int zx_hrxml_Candidate_NUM_CandidateProfile(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateProfile_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CandidateProfile; y; ++n, y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_CandidateProfile) */

struct zx_hrxml_CandidateProfile_s* zx_hrxml_Candidate_GET_CandidateProfile(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x) return 0;
  for (y = x->CandidateProfile; n>=0 && y; --n, y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_CandidateProfile) */

struct zx_hrxml_CandidateProfile_s* zx_hrxml_Candidate_POP_CandidateProfile(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x) return 0;
  y = x->CandidateProfile;
  if (y)
    x->CandidateProfile = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_CandidateProfile) */

void zx_hrxml_Candidate_PUSH_CandidateProfile(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_CandidateProfile_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CandidateProfile->gg.g;
  x->CandidateProfile = z;
}

/* FUNC(zx_hrxml_Candidate_REV_CandidateProfile) */

void zx_hrxml_Candidate_REV_CandidateProfile(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_CandidateProfile_s* nxt;
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x) return;
  y = x->CandidateProfile;
  if (!y) return;
  x->CandidateProfile = 0;
  while (y) {
    nxt = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n;
    y->gg.g.n = &x->CandidateProfile->gg.g;
    x->CandidateProfile = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_CandidateProfile) */

void zx_hrxml_Candidate_PUT_CandidateProfile(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateProfile_s* z)
{
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x || !z) return;
  y = x->CandidateProfile;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CandidateProfile = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_CandidateProfile) */

void zx_hrxml_Candidate_ADD_CandidateProfile(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_CandidateProfile_s* z)
{
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CandidateProfile->gg.g;
    x->CandidateProfile = z;
    return;
  case -1:
    y = x->CandidateProfile;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateProfile; n > 1 && y; --n, y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_CandidateProfile) */

void zx_hrxml_Candidate_DEL_CandidateProfile(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_CandidateProfile_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CandidateProfile = (struct zx_hrxml_CandidateProfile_s*)x->CandidateProfile->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CandidateProfile_s*)x->CandidateProfile;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CandidateProfile; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CandidateProfile_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_Resume) */

int zx_hrxml_Candidate_NUM_Resume(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_Resume_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Resume; y; ++n, y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_Resume) */

struct zx_hrxml_Resume_s* zx_hrxml_Candidate_GET_Resume(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_Resume_s* y;
  if (!x) return 0;
  for (y = x->Resume; n>=0 && y; --n, y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_Resume) */

struct zx_hrxml_Resume_s* zx_hrxml_Candidate_POP_Resume(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_Resume_s* y;
  if (!x) return 0;
  y = x->Resume;
  if (y)
    x->Resume = (struct zx_hrxml_Resume_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_Resume) */

void zx_hrxml_Candidate_PUSH_Resume(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_Resume_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Resume->gg.g;
  x->Resume = z;
}

/* FUNC(zx_hrxml_Candidate_REV_Resume) */

void zx_hrxml_Candidate_REV_Resume(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_Resume_s* nxt;
  struct zx_hrxml_Resume_s* y;
  if (!x) return;
  y = x->Resume;
  if (!y) return;
  x->Resume = 0;
  while (y) {
    nxt = (struct zx_hrxml_Resume_s*)y->gg.g.n;
    y->gg.g.n = &x->Resume->gg.g;
    x->Resume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_Resume) */

void zx_hrxml_Candidate_PUT_Resume(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_Resume_s* z)
{
  struct zx_hrxml_Resume_s* y;
  if (!x || !z) return;
  y = x->Resume;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Resume = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_Resume) */

void zx_hrxml_Candidate_ADD_Resume(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_Resume_s* z)
{
  struct zx_hrxml_Resume_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Resume->gg.g;
    x->Resume = z;
    return;
  case -1:
    y = x->Resume;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Resume; n > 1 && y; --n, y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_Resume) */

void zx_hrxml_Candidate_DEL_Resume(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_Resume_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Resume = (struct zx_hrxml_Resume_s*)x->Resume->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Resume_s*)x->Resume;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Resume; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Resume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Candidate_NUM_UserArea) */

int zx_hrxml_Candidate_NUM_UserArea(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Candidate_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Candidate_GET_UserArea(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Candidate_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Candidate_POP_UserArea(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Candidate_PUSH_UserArea) */

void zx_hrxml_Candidate_PUSH_UserArea(struct zx_hrxml_Candidate_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_Candidate_REV_UserArea) */

void zx_hrxml_Candidate_REV_UserArea(struct zx_hrxml_Candidate_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Candidate_PUT_UserArea) */

void zx_hrxml_Candidate_PUT_UserArea(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Candidate_ADD_UserArea) */

void zx_hrxml_Candidate_ADD_UserArea(struct zx_hrxml_Candidate_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Candidate_DEL_UserArea) */

void zx_hrxml_Candidate_DEL_UserArea(struct zx_hrxml_Candidate_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Candidate_GET_lang) */
struct zx_str* zx_hrxml_Candidate_GET_lang(struct zx_hrxml_Candidate_s* x) { return x->lang; }
/* FUNC(zx_hrxml_Candidate_PUT_lang) */
void zx_hrxml_Candidate_PUT_lang(struct zx_hrxml_Candidate_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_ProfileId) */

int zx_hrxml_CandidateProfile_NUM_ProfileId(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_ProfileId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProfileId; y; ++n, y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_ProfileId) */

struct zx_hrxml_ProfileId_s* zx_hrxml_CandidateProfile_GET_ProfileId(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_ProfileId_s* y;
  if (!x) return 0;
  for (y = x->ProfileId; n>=0 && y; --n, y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_ProfileId) */

struct zx_hrxml_ProfileId_s* zx_hrxml_CandidateProfile_POP_ProfileId(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_ProfileId_s* y;
  if (!x) return 0;
  y = x->ProfileId;
  if (y)
    x->ProfileId = (struct zx_hrxml_ProfileId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_ProfileId) */

void zx_hrxml_CandidateProfile_PUSH_ProfileId(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_ProfileId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ProfileId->gg.g;
  x->ProfileId = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_ProfileId) */

void zx_hrxml_CandidateProfile_REV_ProfileId(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_ProfileId_s* nxt;
  struct zx_hrxml_ProfileId_s* y;
  if (!x) return;
  y = x->ProfileId;
  if (!y) return;
  x->ProfileId = 0;
  while (y) {
    nxt = (struct zx_hrxml_ProfileId_s*)y->gg.g.n;
    y->gg.g.n = &x->ProfileId->gg.g;
    x->ProfileId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_ProfileId) */

void zx_hrxml_CandidateProfile_PUT_ProfileId(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_ProfileId_s* z)
{
  struct zx_hrxml_ProfileId_s* y;
  if (!x || !z) return;
  y = x->ProfileId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ProfileId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_ProfileId) */

void zx_hrxml_CandidateProfile_ADD_ProfileId(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_ProfileId_s* z)
{
  struct zx_hrxml_ProfileId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ProfileId->gg.g;
    x->ProfileId = z;
    return;
  case -1:
    y = x->ProfileId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProfileId; n > 1 && y; --n, y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_ProfileId) */

void zx_hrxml_CandidateProfile_DEL_ProfileId(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_ProfileId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProfileId = (struct zx_hrxml_ProfileId_s*)x->ProfileId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ProfileId_s*)x->ProfileId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProfileId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProfileId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_ProfileName) */

int zx_hrxml_CandidateProfile_NUM_ProfileName(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProfileName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_ProfileName) */

struct zx_elem_s* zx_hrxml_CandidateProfile_GET_ProfileName(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ProfileName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_ProfileName) */

struct zx_elem_s* zx_hrxml_CandidateProfile_POP_ProfileName(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ProfileName;
  if (y)
    x->ProfileName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_ProfileName) */

void zx_hrxml_CandidateProfile_PUSH_ProfileName(struct zx_hrxml_CandidateProfile_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ProfileName->g;
  x->ProfileName = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_ProfileName) */

void zx_hrxml_CandidateProfile_REV_ProfileName(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ProfileName;
  if (!y) return;
  x->ProfileName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ProfileName->g;
    x->ProfileName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_ProfileName) */

void zx_hrxml_CandidateProfile_PUT_ProfileName(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ProfileName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ProfileName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_ProfileName) */

void zx_hrxml_CandidateProfile_ADD_ProfileName(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ProfileName->g;
    x->ProfileName = z;
    return;
  case -1:
    y = x->ProfileName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ProfileName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_ProfileName) */

void zx_hrxml_CandidateProfile_DEL_ProfileName(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProfileName = (struct zx_elem_s*)x->ProfileName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ProfileName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ProfileName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_AvailabilityInfo) */

int zx_hrxml_CandidateProfile_NUM_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AvailabilityInfo; y; ++n, y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_AvailabilityInfo) */

struct zx_hrxml_AvailabilityInfo_s* zx_hrxml_CandidateProfile_GET_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x) return 0;
  for (y = x->AvailabilityInfo; n>=0 && y; --n, y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_AvailabilityInfo) */

struct zx_hrxml_AvailabilityInfo_s* zx_hrxml_CandidateProfile_POP_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x) return 0;
  y = x->AvailabilityInfo;
  if (y)
    x->AvailabilityInfo = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_AvailabilityInfo) */

void zx_hrxml_CandidateProfile_PUSH_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_AvailabilityInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AvailabilityInfo->gg.g;
  x->AvailabilityInfo = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_AvailabilityInfo) */

void zx_hrxml_CandidateProfile_REV_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_AvailabilityInfo_s* nxt;
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x) return;
  y = x->AvailabilityInfo;
  if (!y) return;
  x->AvailabilityInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->AvailabilityInfo->gg.g;
    x->AvailabilityInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_AvailabilityInfo) */

void zx_hrxml_CandidateProfile_PUT_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_AvailabilityInfo_s* z)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x || !z) return;
  y = x->AvailabilityInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AvailabilityInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_AvailabilityInfo) */

void zx_hrxml_CandidateProfile_ADD_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_AvailabilityInfo_s* z)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AvailabilityInfo->gg.g;
    x->AvailabilityInfo = z;
    return;
  case -1:
    y = x->AvailabilityInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AvailabilityInfo; n > 1 && y; --n, y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_AvailabilityInfo) */

void zx_hrxml_CandidateProfile_DEL_AvailabilityInfo(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_AvailabilityInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AvailabilityInfo = (struct zx_hrxml_AvailabilityInfo_s*)x->AvailabilityInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AvailabilityInfo_s*)x->AvailabilityInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AvailabilityInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AvailabilityInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_DistributionGuidelines) */

int zx_hrxml_CandidateProfile_NUM_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_CandidateProfile_GET_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_CandidateProfile_POP_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DistributionGuidelines;
  if (y)
    x->DistributionGuidelines = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_DistributionGuidelines) */

void zx_hrxml_CandidateProfile_PUSH_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DistributionGuidelines->g;
  x->DistributionGuidelines = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_DistributionGuidelines) */

void zx_hrxml_CandidateProfile_REV_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  x->DistributionGuidelines = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_DistributionGuidelines) */

void zx_hrxml_CandidateProfile_PUT_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DistributionGuidelines = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_DistributionGuidelines) */

void zx_hrxml_CandidateProfile_ADD_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = z;
    return;
  case -1:
    y = x->DistributionGuidelines;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_DistributionGuidelines) */

void zx_hrxml_CandidateProfile_DEL_DistributionGuidelines(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DistributionGuidelines = (struct zx_elem_s*)x->DistributionGuidelines->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DistributionGuidelines;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_PersonalData) */

int zx_hrxml_CandidateProfile_NUM_PersonalData(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PersonalData_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonalData; y; ++n, y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_PersonalData) */

struct zx_hrxml_PersonalData_s* zx_hrxml_CandidateProfile_GET_PersonalData(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_PersonalData_s* y;
  if (!x) return 0;
  for (y = x->PersonalData; n>=0 && y; --n, y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_PersonalData) */

struct zx_hrxml_PersonalData_s* zx_hrxml_CandidateProfile_POP_PersonalData(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PersonalData_s* y;
  if (!x) return 0;
  y = x->PersonalData;
  if (y)
    x->PersonalData = (struct zx_hrxml_PersonalData_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_PersonalData) */

void zx_hrxml_CandidateProfile_PUSH_PersonalData(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_PersonalData_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonalData->gg.g;
  x->PersonalData = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_PersonalData) */

void zx_hrxml_CandidateProfile_REV_PersonalData(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PersonalData_s* nxt;
  struct zx_hrxml_PersonalData_s* y;
  if (!x) return;
  y = x->PersonalData;
  if (!y) return;
  x->PersonalData = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonalData_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonalData->gg.g;
    x->PersonalData = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_PersonalData) */

void zx_hrxml_CandidateProfile_PUT_PersonalData(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_PersonalData_s* z)
{
  struct zx_hrxml_PersonalData_s* y;
  if (!x || !z) return;
  y = x->PersonalData;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonalData = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_PersonalData) */

void zx_hrxml_CandidateProfile_ADD_PersonalData(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_PersonalData_s* z)
{
  struct zx_hrxml_PersonalData_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonalData->gg.g;
    x->PersonalData = z;
    return;
  case -1:
    y = x->PersonalData;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonalData; n > 1 && y; --n, y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_PersonalData) */

void zx_hrxml_CandidateProfile_DEL_PersonalData(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_PersonalData_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonalData = (struct zx_hrxml_PersonalData_s*)x->PersonalData->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonalData_s*)x->PersonalData;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonalData; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonalData_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_PreferredPosition) */

int zx_hrxml_CandidateProfile_NUM_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PreferredPosition_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredPosition; y; ++n, y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_PreferredPosition) */

struct zx_hrxml_PreferredPosition_s* zx_hrxml_CandidateProfile_GET_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x) return 0;
  for (y = x->PreferredPosition; n>=0 && y; --n, y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_PreferredPosition) */

struct zx_hrxml_PreferredPosition_s* zx_hrxml_CandidateProfile_POP_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x) return 0;
  y = x->PreferredPosition;
  if (y)
    x->PreferredPosition = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_PreferredPosition) */

void zx_hrxml_CandidateProfile_PUSH_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_PreferredPosition_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PreferredPosition->gg.g;
  x->PreferredPosition = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_PreferredPosition) */

void zx_hrxml_CandidateProfile_REV_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_PreferredPosition_s* nxt;
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x) return;
  y = x->PreferredPosition;
  if (!y) return;
  x->PreferredPosition = 0;
  while (y) {
    nxt = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n;
    y->gg.g.n = &x->PreferredPosition->gg.g;
    x->PreferredPosition = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_PreferredPosition) */

void zx_hrxml_CandidateProfile_PUT_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_PreferredPosition_s* z)
{
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x || !z) return;
  y = x->PreferredPosition;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PreferredPosition = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_PreferredPosition) */

void zx_hrxml_CandidateProfile_ADD_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_PreferredPosition_s* z)
{
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PreferredPosition->gg.g;
    x->PreferredPosition = z;
    return;
  case -1:
    y = x->PreferredPosition;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredPosition; n > 1 && y; --n, y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_PreferredPosition) */

void zx_hrxml_CandidateProfile_DEL_PreferredPosition(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_PreferredPosition_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredPosition = (struct zx_hrxml_PreferredPosition_s*)x->PreferredPosition->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PreferredPosition_s*)x->PreferredPosition;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredPosition; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredPosition_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_EmploymentHistory) */

int zx_hrxml_CandidateProfile_NUM_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EmploymentHistory; y; ++n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_EmploymentHistory) */

struct zx_hrxml_EmploymentHistory_s* zx_hrxml_CandidateProfile_GET_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return 0;
  for (y = x->EmploymentHistory; n>=0 && y; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_EmploymentHistory) */

struct zx_hrxml_EmploymentHistory_s* zx_hrxml_CandidateProfile_POP_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return 0;
  y = x->EmploymentHistory;
  if (y)
    x->EmploymentHistory = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_EmploymentHistory) */

void zx_hrxml_CandidateProfile_PUSH_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_EmploymentHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EmploymentHistory->gg.g;
  x->EmploymentHistory = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_EmploymentHistory) */

void zx_hrxml_CandidateProfile_REV_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* nxt;
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return;
  y = x->EmploymentHistory;
  if (!y) return;
  x->EmploymentHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->EmploymentHistory->gg.g;
    x->EmploymentHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_EmploymentHistory) */

void zx_hrxml_CandidateProfile_PUT_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_EmploymentHistory_s* z)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x || !z) return;
  y = x->EmploymentHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EmploymentHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_EmploymentHistory) */

void zx_hrxml_CandidateProfile_ADD_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_EmploymentHistory_s* z)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EmploymentHistory->gg.g;
    x->EmploymentHistory = z;
    return;
  case -1:
    y = x->EmploymentHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmploymentHistory; n > 1 && y; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_EmploymentHistory) */

void zx_hrxml_CandidateProfile_DEL_EmploymentHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EmploymentHistory = (struct zx_hrxml_EmploymentHistory_s*)x->EmploymentHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EmploymentHistory_s*)x->EmploymentHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmploymentHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_EducationHistory) */

int zx_hrxml_CandidateProfile_NUM_EducationHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EducationHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EducationHistory; y; ++n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_EducationHistory) */

struct zx_hrxml_EducationHistory_s* zx_hrxml_CandidateProfile_GET_EducationHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return 0;
  for (y = x->EducationHistory; n>=0 && y; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_EducationHistory) */

struct zx_hrxml_EducationHistory_s* zx_hrxml_CandidateProfile_POP_EducationHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return 0;
  y = x->EducationHistory;
  if (y)
    x->EducationHistory = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_EducationHistory) */

void zx_hrxml_CandidateProfile_PUSH_EducationHistory(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_EducationHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EducationHistory->gg.g;
  x->EducationHistory = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_EducationHistory) */

void zx_hrxml_CandidateProfile_REV_EducationHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_EducationHistory_s* nxt;
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return;
  y = x->EducationHistory;
  if (!y) return;
  x->EducationHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->EducationHistory->gg.g;
    x->EducationHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_EducationHistory) */

void zx_hrxml_CandidateProfile_PUT_EducationHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_EducationHistory_s* z)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x || !z) return;
  y = x->EducationHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EducationHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_EducationHistory) */

void zx_hrxml_CandidateProfile_ADD_EducationHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_EducationHistory_s* z)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EducationHistory->gg.g;
    x->EducationHistory = z;
    return;
  case -1:
    y = x->EducationHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationHistory; n > 1 && y; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_EducationHistory) */

void zx_hrxml_CandidateProfile_DEL_EducationHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EducationHistory = (struct zx_hrxml_EducationHistory_s*)x->EducationHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EducationHistory_s*)x->EducationHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_MilitaryHistory) */

int zx_hrxml_CandidateProfile_NUM_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MilitaryHistory; y; ++n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_MilitaryHistory) */

struct zx_hrxml_MilitaryHistory_s* zx_hrxml_CandidateProfile_GET_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return 0;
  for (y = x->MilitaryHistory; n>=0 && y; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_MilitaryHistory) */

struct zx_hrxml_MilitaryHistory_s* zx_hrxml_CandidateProfile_POP_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return 0;
  y = x->MilitaryHistory;
  if (y)
    x->MilitaryHistory = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_MilitaryHistory) */

void zx_hrxml_CandidateProfile_PUSH_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_MilitaryHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->MilitaryHistory->gg.g;
  x->MilitaryHistory = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_MilitaryHistory) */

void zx_hrxml_CandidateProfile_REV_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* nxt;
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return;
  y = x->MilitaryHistory;
  if (!y) return;
  x->MilitaryHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->MilitaryHistory->gg.g;
    x->MilitaryHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_MilitaryHistory) */

void zx_hrxml_CandidateProfile_PUT_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_MilitaryHistory_s* z)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x || !z) return;
  y = x->MilitaryHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->MilitaryHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_MilitaryHistory) */

void zx_hrxml_CandidateProfile_ADD_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_MilitaryHistory_s* z)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->MilitaryHistory->gg.g;
    x->MilitaryHistory = z;
    return;
  case -1:
    y = x->MilitaryHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryHistory; n > 1 && y; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_MilitaryHistory) */

void zx_hrxml_CandidateProfile_DEL_MilitaryHistory(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MilitaryHistory = (struct zx_hrxml_MilitaryHistory_s*)x->MilitaryHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_MilitaryHistory_s*)x->MilitaryHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_Associations) */

int zx_hrxml_CandidateProfile_NUM_Associations(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_Associations_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Associations; y; ++n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_Associations) */

struct zx_hrxml_Associations_s* zx_hrxml_CandidateProfile_GET_Associations(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return 0;
  for (y = x->Associations; n>=0 && y; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_Associations) */

struct zx_hrxml_Associations_s* zx_hrxml_CandidateProfile_POP_Associations(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return 0;
  y = x->Associations;
  if (y)
    x->Associations = (struct zx_hrxml_Associations_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_Associations) */

void zx_hrxml_CandidateProfile_PUSH_Associations(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_Associations_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Associations->gg.g;
  x->Associations = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_Associations) */

void zx_hrxml_CandidateProfile_REV_Associations(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_Associations_s* nxt;
  struct zx_hrxml_Associations_s* y;
  if (!x) return;
  y = x->Associations;
  if (!y) return;
  x->Associations = 0;
  while (y) {
    nxt = (struct zx_hrxml_Associations_s*)y->gg.g.n;
    y->gg.g.n = &x->Associations->gg.g;
    x->Associations = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_Associations) */

void zx_hrxml_CandidateProfile_PUT_Associations(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_Associations_s* z)
{
  struct zx_hrxml_Associations_s* y;
  if (!x || !z) return;
  y = x->Associations;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Associations = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_Associations) */

void zx_hrxml_CandidateProfile_ADD_Associations(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_Associations_s* z)
{
  struct zx_hrxml_Associations_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Associations->gg.g;
    x->Associations = z;
    return;
  case -1:
    y = x->Associations;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Associations; n > 1 && y; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_Associations) */

void zx_hrxml_CandidateProfile_DEL_Associations(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Associations = (struct zx_hrxml_Associations_s*)x->Associations->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Associations_s*)x->Associations;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Associations; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_SupportingMaterials) */

int zx_hrxml_CandidateProfile_NUM_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingMaterials; y; ++n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_CandidateProfile_GET_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  for (y = x->SupportingMaterials; n>=0 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_CandidateProfile_POP_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  y = x->SupportingMaterials;
  if (y)
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_SupportingMaterials) */

void zx_hrxml_CandidateProfile_PUSH_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_SupportingMaterials_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SupportingMaterials->gg.g;
  x->SupportingMaterials = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_SupportingMaterials) */

void zx_hrxml_CandidateProfile_REV_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* nxt;
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  y = x->SupportingMaterials;
  if (!y) return;
  x->SupportingMaterials = 0;
  while (y) {
    nxt = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
    y->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_SupportingMaterials) */

void zx_hrxml_CandidateProfile_PUT_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  y = x->SupportingMaterials;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SupportingMaterials = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_SupportingMaterials) */

void zx_hrxml_CandidateProfile_ADD_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = z;
    return;
  case -1:
    y = x->SupportingMaterials;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_SupportingMaterials) */

void zx_hrxml_CandidateProfile_DEL_SupportingMaterials(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateProfile_NUM_UserArea) */

int zx_hrxml_CandidateProfile_NUM_UserArea(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateProfile_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_CandidateProfile_GET_UserArea(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_CandidateProfile_POP_UserArea(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateProfile_PUSH_UserArea) */

void zx_hrxml_CandidateProfile_PUSH_UserArea(struct zx_hrxml_CandidateProfile_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_CandidateProfile_REV_UserArea) */

void zx_hrxml_CandidateProfile_REV_UserArea(struct zx_hrxml_CandidateProfile_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_PUT_UserArea) */

void zx_hrxml_CandidateProfile_PUT_UserArea(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateProfile_ADD_UserArea) */

void zx_hrxml_CandidateProfile_ADD_UserArea(struct zx_hrxml_CandidateProfile_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateProfile_DEL_UserArea) */

void zx_hrxml_CandidateProfile_DEL_UserArea(struct zx_hrxml_CandidateProfile_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_CandidateProfile_GET_lang) */
struct zx_str* zx_hrxml_CandidateProfile_GET_lang(struct zx_hrxml_CandidateProfile_s* x) { return x->lang; }
/* FUNC(zx_hrxml_CandidateProfile_PUT_lang) */
void zx_hrxml_CandidateProfile_PUT_lang(struct zx_hrxml_CandidateProfile_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateRecordInfo_NUM_Id) */

int zx_hrxml_CandidateRecordInfo_NUM_Id(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_CandidateRecordInfo_GET_Id(struct zx_hrxml_CandidateRecordInfo_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_CandidateRecordInfo_POP_Id(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_PUSH_Id) */

void zx_hrxml_CandidateRecordInfo_PUSH_Id(struct zx_hrxml_CandidateRecordInfo_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_REV_Id) */

void zx_hrxml_CandidateRecordInfo_REV_Id(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateRecordInfo_PUT_Id) */

void zx_hrxml_CandidateRecordInfo_PUT_Id(struct zx_hrxml_CandidateRecordInfo_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateRecordInfo_ADD_Id) */

void zx_hrxml_CandidateRecordInfo_ADD_Id(struct zx_hrxml_CandidateRecordInfo_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_DEL_Id) */

void zx_hrxml_CandidateRecordInfo_DEL_Id(struct zx_hrxml_CandidateRecordInfo_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateRecordInfo_NUM_Status) */

int zx_hrxml_CandidateRecordInfo_NUM_Status(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Status_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Status; y; ++n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_GET_Status) */

struct zx_hrxml_Status_s* zx_hrxml_CandidateRecordInfo_GET_Status(struct zx_hrxml_CandidateRecordInfo_s* x, int n)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return 0;
  for (y = x->Status; n>=0 && y; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_POP_Status) */

struct zx_hrxml_Status_s* zx_hrxml_CandidateRecordInfo_POP_Status(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return 0;
  y = x->Status;
  if (y)
    x->Status = (struct zx_hrxml_Status_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_PUSH_Status) */

void zx_hrxml_CandidateRecordInfo_PUSH_Status(struct zx_hrxml_CandidateRecordInfo_s* x, struct zx_hrxml_Status_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Status->gg.g;
  x->Status = z;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_REV_Status) */

void zx_hrxml_CandidateRecordInfo_REV_Status(struct zx_hrxml_CandidateRecordInfo_s* x)
{
  struct zx_hrxml_Status_s* nxt;
  struct zx_hrxml_Status_s* y;
  if (!x) return;
  y = x->Status;
  if (!y) return;
  x->Status = 0;
  while (y) {
    nxt = (struct zx_hrxml_Status_s*)y->gg.g.n;
    y->gg.g.n = &x->Status->gg.g;
    x->Status = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateRecordInfo_PUT_Status) */

void zx_hrxml_CandidateRecordInfo_PUT_Status(struct zx_hrxml_CandidateRecordInfo_s* x, int n, struct zx_hrxml_Status_s* z)
{
  struct zx_hrxml_Status_s* y;
  if (!x || !z) return;
  y = x->Status;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Status = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateRecordInfo_ADD_Status) */

void zx_hrxml_CandidateRecordInfo_ADD_Status(struct zx_hrxml_CandidateRecordInfo_s* x, int n, struct zx_hrxml_Status_s* z)
{
  struct zx_hrxml_Status_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Status->gg.g;
    x->Status = z;
    return;
  case -1:
    y = x->Status;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Status; n > 1 && y; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateRecordInfo_DEL_Status) */

void zx_hrxml_CandidateRecordInfo_DEL_Status(struct zx_hrxml_CandidateRecordInfo_s* x, int n)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Status = (struct zx_hrxml_Status_s*)x->Status->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Status_s*)x->Status;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Status; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateSupplier_NUM_SupplierId) */

int zx_hrxml_CandidateSupplier_NUM_SupplierId(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SupplierId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupplierId; y; ++n, y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateSupplier_GET_SupplierId) */

struct zx_hrxml_SupplierId_s* zx_hrxml_CandidateSupplier_GET_SupplierId(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_SupplierId_s* y;
  if (!x) return 0;
  for (y = x->SupplierId; n>=0 && y; --n, y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_POP_SupplierId) */

struct zx_hrxml_SupplierId_s* zx_hrxml_CandidateSupplier_POP_SupplierId(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SupplierId_s* y;
  if (!x) return 0;
  y = x->SupplierId;
  if (y)
    x->SupplierId = (struct zx_hrxml_SupplierId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_PUSH_SupplierId) */

void zx_hrxml_CandidateSupplier_PUSH_SupplierId(struct zx_hrxml_CandidateSupplier_s* x, struct zx_hrxml_SupplierId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SupplierId->gg.g;
  x->SupplierId = z;
}

/* FUNC(zx_hrxml_CandidateSupplier_REV_SupplierId) */

void zx_hrxml_CandidateSupplier_REV_SupplierId(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SupplierId_s* nxt;
  struct zx_hrxml_SupplierId_s* y;
  if (!x) return;
  y = x->SupplierId;
  if (!y) return;
  x->SupplierId = 0;
  while (y) {
    nxt = (struct zx_hrxml_SupplierId_s*)y->gg.g.n;
    y->gg.g.n = &x->SupplierId->gg.g;
    x->SupplierId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_PUT_SupplierId) */

void zx_hrxml_CandidateSupplier_PUT_SupplierId(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_SupplierId_s* z)
{
  struct zx_hrxml_SupplierId_s* y;
  if (!x || !z) return;
  y = x->SupplierId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SupplierId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_ADD_SupplierId) */

void zx_hrxml_CandidateSupplier_ADD_SupplierId(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_SupplierId_s* z)
{
  struct zx_hrxml_SupplierId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SupplierId->gg.g;
    x->SupplierId = z;
    return;
  case -1:
    y = x->SupplierId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupplierId; n > 1 && y; --n, y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateSupplier_DEL_SupplierId) */

void zx_hrxml_CandidateSupplier_DEL_SupplierId(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_SupplierId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupplierId = (struct zx_hrxml_SupplierId_s*)x->SupplierId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SupplierId_s*)x->SupplierId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupplierId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupplierId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateSupplier_NUM_EntityName) */

int zx_hrxml_CandidateSupplier_NUM_EntityName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EntityName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateSupplier_GET_EntityName) */

struct zx_elem_s* zx_hrxml_CandidateSupplier_GET_EntityName(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EntityName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_POP_EntityName) */

struct zx_elem_s* zx_hrxml_CandidateSupplier_POP_EntityName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EntityName;
  if (y)
    x->EntityName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_PUSH_EntityName) */

void zx_hrxml_CandidateSupplier_PUSH_EntityName(struct zx_hrxml_CandidateSupplier_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EntityName->g;
  x->EntityName = z;
}

/* FUNC(zx_hrxml_CandidateSupplier_REV_EntityName) */

void zx_hrxml_CandidateSupplier_REV_EntityName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EntityName;
  if (!y) return;
  x->EntityName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EntityName->g;
    x->EntityName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_PUT_EntityName) */

void zx_hrxml_CandidateSupplier_PUT_EntityName(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EntityName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EntityName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_ADD_EntityName) */

void zx_hrxml_CandidateSupplier_ADD_EntityName(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EntityName->g;
    x->EntityName = z;
    return;
  case -1:
    y = x->EntityName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EntityName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_CandidateSupplier_DEL_EntityName) */

void zx_hrxml_CandidateSupplier_DEL_EntityName(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EntityName = (struct zx_elem_s*)x->EntityName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EntityName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EntityName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateSupplier_NUM_ContactName) */

int zx_hrxml_CandidateSupplier_NUM_ContactName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactName; y; ++n, y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateSupplier_GET_ContactName) */

struct zx_hrxml_ContactName_s* zx_hrxml_CandidateSupplier_GET_ContactName(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_ContactName_s* y;
  if (!x) return 0;
  for (y = x->ContactName; n>=0 && y; --n, y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_POP_ContactName) */

struct zx_hrxml_ContactName_s* zx_hrxml_CandidateSupplier_POP_ContactName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactName_s* y;
  if (!x) return 0;
  y = x->ContactName;
  if (y)
    x->ContactName = (struct zx_hrxml_ContactName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_PUSH_ContactName) */

void zx_hrxml_CandidateSupplier_PUSH_ContactName(struct zx_hrxml_CandidateSupplier_s* x, struct zx_hrxml_ContactName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactName->gg.g;
  x->ContactName = z;
}

/* FUNC(zx_hrxml_CandidateSupplier_REV_ContactName) */

void zx_hrxml_CandidateSupplier_REV_ContactName(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactName_s* nxt;
  struct zx_hrxml_ContactName_s* y;
  if (!x) return;
  y = x->ContactName;
  if (!y) return;
  x->ContactName = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactName_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactName->gg.g;
    x->ContactName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_PUT_ContactName) */

void zx_hrxml_CandidateSupplier_PUT_ContactName(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_ContactName_s* z)
{
  struct zx_hrxml_ContactName_s* y;
  if (!x || !z) return;
  y = x->ContactName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_ADD_ContactName) */

void zx_hrxml_CandidateSupplier_ADD_ContactName(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_ContactName_s* z)
{
  struct zx_hrxml_ContactName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactName->gg.g;
    x->ContactName = z;
    return;
  case -1:
    y = x->ContactName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactName; n > 1 && y; --n, y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateSupplier_DEL_ContactName) */

void zx_hrxml_CandidateSupplier_DEL_ContactName(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_ContactName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactName = (struct zx_hrxml_ContactName_s*)x->ContactName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactName_s*)x->ContactName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateSupplier_NUM_ContactMethod) */

int zx_hrxml_CandidateSupplier_NUM_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateSupplier_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_CandidateSupplier_GET_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_CandidateSupplier_POP_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_PUSH_ContactMethod) */

void zx_hrxml_CandidateSupplier_PUSH_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_CandidateSupplier_REV_ContactMethod) */

void zx_hrxml_CandidateSupplier_REV_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_PUT_ContactMethod) */

void zx_hrxml_CandidateSupplier_PUT_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_ADD_ContactMethod) */

void zx_hrxml_CandidateSupplier_ADD_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateSupplier_DEL_ContactMethod) */

void zx_hrxml_CandidateSupplier_DEL_ContactMethod(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CandidateSupplier_NUM_SourceType) */

int zx_hrxml_CandidateSupplier_NUM_SourceType(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SourceType_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SourceType; y; ++n, y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CandidateSupplier_GET_SourceType) */

struct zx_hrxml_SourceType_s* zx_hrxml_CandidateSupplier_GET_SourceType(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_SourceType_s* y;
  if (!x) return 0;
  for (y = x->SourceType; n>=0 && y; --n, y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_POP_SourceType) */

struct zx_hrxml_SourceType_s* zx_hrxml_CandidateSupplier_POP_SourceType(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SourceType_s* y;
  if (!x) return 0;
  y = x->SourceType;
  if (y)
    x->SourceType = (struct zx_hrxml_SourceType_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CandidateSupplier_PUSH_SourceType) */

void zx_hrxml_CandidateSupplier_PUSH_SourceType(struct zx_hrxml_CandidateSupplier_s* x, struct zx_hrxml_SourceType_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SourceType->gg.g;
  x->SourceType = z;
}

/* FUNC(zx_hrxml_CandidateSupplier_REV_SourceType) */

void zx_hrxml_CandidateSupplier_REV_SourceType(struct zx_hrxml_CandidateSupplier_s* x)
{
  struct zx_hrxml_SourceType_s* nxt;
  struct zx_hrxml_SourceType_s* y;
  if (!x) return;
  y = x->SourceType;
  if (!y) return;
  x->SourceType = 0;
  while (y) {
    nxt = (struct zx_hrxml_SourceType_s*)y->gg.g.n;
    y->gg.g.n = &x->SourceType->gg.g;
    x->SourceType = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_PUT_SourceType) */

void zx_hrxml_CandidateSupplier_PUT_SourceType(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_SourceType_s* z)
{
  struct zx_hrxml_SourceType_s* y;
  if (!x || !z) return;
  y = x->SourceType;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SourceType = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CandidateSupplier_ADD_SourceType) */

void zx_hrxml_CandidateSupplier_ADD_SourceType(struct zx_hrxml_CandidateSupplier_s* x, int n, struct zx_hrxml_SourceType_s* z)
{
  struct zx_hrxml_SourceType_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SourceType->gg.g;
    x->SourceType = z;
    return;
  case -1:
    y = x->SourceType;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SourceType; n > 1 && y; --n, y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CandidateSupplier_DEL_SourceType) */

void zx_hrxml_CandidateSupplier_DEL_SourceType(struct zx_hrxml_CandidateSupplier_s* x, int n)
{
  struct zx_hrxml_SourceType_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SourceType = (struct zx_hrxml_SourceType_s*)x->SourceType->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SourceType_s*)x->SourceType;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SourceType; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SourceType_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_CandidateSupplier_GET_relationship) */
struct zx_str* zx_hrxml_CandidateSupplier_GET_relationship(struct zx_hrxml_CandidateSupplier_s* x) { return x->relationship; }
/* FUNC(zx_hrxml_CandidateSupplier_PUT_relationship) */
void zx_hrxml_CandidateSupplier_PUT_relationship(struct zx_hrxml_CandidateSupplier_s* x, struct zx_str* y) { x->relationship = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ChildrenInfo_NUM_NumberOfChildren) */

int zx_hrxml_ChildrenInfo_NUM_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumberOfChildren; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ChildrenInfo_GET_NumberOfChildren) */

struct zx_elem_s* zx_hrxml_ChildrenInfo_GET_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->NumberOfChildren; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ChildrenInfo_POP_NumberOfChildren) */

struct zx_elem_s* zx_hrxml_ChildrenInfo_POP_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->NumberOfChildren;
  if (y)
    x->NumberOfChildren = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ChildrenInfo_PUSH_NumberOfChildren) */

void zx_hrxml_ChildrenInfo_PUSH_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->NumberOfChildren->g;
  x->NumberOfChildren = z;
}

/* FUNC(zx_hrxml_ChildrenInfo_REV_NumberOfChildren) */

void zx_hrxml_ChildrenInfo_REV_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->NumberOfChildren;
  if (!y) return;
  x->NumberOfChildren = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->NumberOfChildren->g;
    x->NumberOfChildren = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ChildrenInfo_PUT_NumberOfChildren) */

void zx_hrxml_ChildrenInfo_PUT_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->NumberOfChildren;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->NumberOfChildren = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ChildrenInfo_ADD_NumberOfChildren) */

void zx_hrxml_ChildrenInfo_ADD_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->NumberOfChildren->g;
    x->NumberOfChildren = z;
    return;
  case -1:
    y = x->NumberOfChildren;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfChildren; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ChildrenInfo_DEL_NumberOfChildren) */

void zx_hrxml_ChildrenInfo_DEL_NumberOfChildren(struct zx_hrxml_ChildrenInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumberOfChildren = (struct zx_elem_s*)x->NumberOfChildren->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->NumberOfChildren;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfChildren; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ChildrenInfo_NUM_Comments) */

int zx_hrxml_ChildrenInfo_NUM_Comments(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ChildrenInfo_GET_Comments) */

struct zx_elem_s* zx_hrxml_ChildrenInfo_GET_Comments(struct zx_hrxml_ChildrenInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ChildrenInfo_POP_Comments) */

struct zx_elem_s* zx_hrxml_ChildrenInfo_POP_Comments(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ChildrenInfo_PUSH_Comments) */

void zx_hrxml_ChildrenInfo_PUSH_Comments(struct zx_hrxml_ChildrenInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_ChildrenInfo_REV_Comments) */

void zx_hrxml_ChildrenInfo_REV_Comments(struct zx_hrxml_ChildrenInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ChildrenInfo_PUT_Comments) */

void zx_hrxml_ChildrenInfo_PUT_Comments(struct zx_hrxml_ChildrenInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ChildrenInfo_ADD_Comments) */

void zx_hrxml_ChildrenInfo_ADD_Comments(struct zx_hrxml_ChildrenInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ChildrenInfo_DEL_Comments) */

void zx_hrxml_ChildrenInfo_DEL_Comments(struct zx_hrxml_ChildrenInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_ClassRank_GET_numberOfStudents) */
struct zx_str* zx_hrxml_ClassRank_GET_numberOfStudents(struct zx_hrxml_ClassRank_s* x) { return x->numberOfStudents; }
/* FUNC(zx_hrxml_ClassRank_PUT_numberOfStudents) */
void zx_hrxml_ClassRank_PUT_numberOfStudents(struct zx_hrxml_ClassRank_s* x, struct zx_str* y) { x->numberOfStudents = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Commute_NUM_TimeMax) */

int zx_hrxml_Commute_NUM_TimeMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_TimeMax_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TimeMax; y; ++n, y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Commute_GET_TimeMax) */

struct zx_hrxml_TimeMax_s* zx_hrxml_Commute_GET_TimeMax(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_hrxml_TimeMax_s* y;
  if (!x) return 0;
  for (y = x->TimeMax; n>=0 && y; --n, y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Commute_POP_TimeMax) */

struct zx_hrxml_TimeMax_s* zx_hrxml_Commute_POP_TimeMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_TimeMax_s* y;
  if (!x) return 0;
  y = x->TimeMax;
  if (y)
    x->TimeMax = (struct zx_hrxml_TimeMax_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Commute_PUSH_TimeMax) */

void zx_hrxml_Commute_PUSH_TimeMax(struct zx_hrxml_Commute_s* x, struct zx_hrxml_TimeMax_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TimeMax->gg.g;
  x->TimeMax = z;
}

/* FUNC(zx_hrxml_Commute_REV_TimeMax) */

void zx_hrxml_Commute_REV_TimeMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_TimeMax_s* nxt;
  struct zx_hrxml_TimeMax_s* y;
  if (!x) return;
  y = x->TimeMax;
  if (!y) return;
  x->TimeMax = 0;
  while (y) {
    nxt = (struct zx_hrxml_TimeMax_s*)y->gg.g.n;
    y->gg.g.n = &x->TimeMax->gg.g;
    x->TimeMax = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Commute_PUT_TimeMax) */

void zx_hrxml_Commute_PUT_TimeMax(struct zx_hrxml_Commute_s* x, int n, struct zx_hrxml_TimeMax_s* z)
{
  struct zx_hrxml_TimeMax_s* y;
  if (!x || !z) return;
  y = x->TimeMax;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TimeMax = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Commute_ADD_TimeMax) */

void zx_hrxml_Commute_ADD_TimeMax(struct zx_hrxml_Commute_s* x, int n, struct zx_hrxml_TimeMax_s* z)
{
  struct zx_hrxml_TimeMax_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TimeMax->gg.g;
    x->TimeMax = z;
    return;
  case -1:
    y = x->TimeMax;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TimeMax; n > 1 && y; --n, y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Commute_DEL_TimeMax) */

void zx_hrxml_Commute_DEL_TimeMax(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_hrxml_TimeMax_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TimeMax = (struct zx_hrxml_TimeMax_s*)x->TimeMax->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TimeMax_s*)x->TimeMax;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TimeMax; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TimeMax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Commute_NUM_DistanceMax) */

int zx_hrxml_Commute_NUM_DistanceMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_DistanceMax_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DistanceMax; y; ++n, y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Commute_GET_DistanceMax) */

struct zx_hrxml_DistanceMax_s* zx_hrxml_Commute_GET_DistanceMax(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_hrxml_DistanceMax_s* y;
  if (!x) return 0;
  for (y = x->DistanceMax; n>=0 && y; --n, y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Commute_POP_DistanceMax) */

struct zx_hrxml_DistanceMax_s* zx_hrxml_Commute_POP_DistanceMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_DistanceMax_s* y;
  if (!x) return 0;
  y = x->DistanceMax;
  if (y)
    x->DistanceMax = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Commute_PUSH_DistanceMax) */

void zx_hrxml_Commute_PUSH_DistanceMax(struct zx_hrxml_Commute_s* x, struct zx_hrxml_DistanceMax_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DistanceMax->gg.g;
  x->DistanceMax = z;
}

/* FUNC(zx_hrxml_Commute_REV_DistanceMax) */

void zx_hrxml_Commute_REV_DistanceMax(struct zx_hrxml_Commute_s* x)
{
  struct zx_hrxml_DistanceMax_s* nxt;
  struct zx_hrxml_DistanceMax_s* y;
  if (!x) return;
  y = x->DistanceMax;
  if (!y) return;
  x->DistanceMax = 0;
  while (y) {
    nxt = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n;
    y->gg.g.n = &x->DistanceMax->gg.g;
    x->DistanceMax = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Commute_PUT_DistanceMax) */

void zx_hrxml_Commute_PUT_DistanceMax(struct zx_hrxml_Commute_s* x, int n, struct zx_hrxml_DistanceMax_s* z)
{
  struct zx_hrxml_DistanceMax_s* y;
  if (!x || !z) return;
  y = x->DistanceMax;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DistanceMax = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Commute_ADD_DistanceMax) */

void zx_hrxml_Commute_ADD_DistanceMax(struct zx_hrxml_Commute_s* x, int n, struct zx_hrxml_DistanceMax_s* z)
{
  struct zx_hrxml_DistanceMax_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DistanceMax->gg.g;
    x->DistanceMax = z;
    return;
  case -1:
    y = x->DistanceMax;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DistanceMax; n > 1 && y; --n, y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Commute_DEL_DistanceMax) */

void zx_hrxml_Commute_DEL_DistanceMax(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_hrxml_DistanceMax_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DistanceMax = (struct zx_hrxml_DistanceMax_s*)x->DistanceMax->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DistanceMax_s*)x->DistanceMax;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DistanceMax; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DistanceMax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Commute_NUM_Comments) */

int zx_hrxml_Commute_NUM_Comments(struct zx_hrxml_Commute_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Commute_GET_Comments) */

struct zx_elem_s* zx_hrxml_Commute_GET_Comments(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Commute_POP_Comments) */

struct zx_elem_s* zx_hrxml_Commute_POP_Comments(struct zx_hrxml_Commute_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Commute_PUSH_Comments) */

void zx_hrxml_Commute_PUSH_Comments(struct zx_hrxml_Commute_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Commute_REV_Comments) */

void zx_hrxml_Commute_REV_Comments(struct zx_hrxml_Commute_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Commute_PUT_Comments) */

void zx_hrxml_Commute_PUT_Comments(struct zx_hrxml_Commute_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Commute_ADD_Comments) */

void zx_hrxml_Commute_ADD_Comments(struct zx_hrxml_Commute_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Commute_DEL_Comments) */

void zx_hrxml_Commute_DEL_Comments(struct zx_hrxml_Commute_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Company_NUM_Id) */

int zx_hrxml_Company_NUM_Id(struct zx_hrxml_Company_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Company_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Company_GET_Id(struct zx_hrxml_Company_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Company_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Company_POP_Id(struct zx_hrxml_Company_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Company_PUSH_Id) */

void zx_hrxml_Company_PUSH_Id(struct zx_hrxml_Company_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_Company_REV_Id) */

void zx_hrxml_Company_REV_Id(struct zx_hrxml_Company_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Company_PUT_Id) */

void zx_hrxml_Company_PUT_Id(struct zx_hrxml_Company_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Company_ADD_Id) */

void zx_hrxml_Company_ADD_Id(struct zx_hrxml_Company_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Company_DEL_Id) */

void zx_hrxml_Company_DEL_Id(struct zx_hrxml_Company_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Company_NUM_Name) */

int zx_hrxml_Company_NUM_Name(struct zx_hrxml_Company_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Company_GET_Name) */

struct zx_elem_s* zx_hrxml_Company_GET_Name(struct zx_hrxml_Company_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Company_POP_Name) */

struct zx_elem_s* zx_hrxml_Company_POP_Name(struct zx_hrxml_Company_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Company_PUSH_Name) */

void zx_hrxml_Company_PUSH_Name(struct zx_hrxml_Company_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_Company_REV_Name) */

void zx_hrxml_Company_REV_Name(struct zx_hrxml_Company_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Company_PUT_Name) */

void zx_hrxml_Company_PUT_Name(struct zx_hrxml_Company_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Company_ADD_Name) */

void zx_hrxml_Company_ADD_Name(struct zx_hrxml_Company_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Company_DEL_Name) */

void zx_hrxml_Company_DEL_Name(struct zx_hrxml_Company_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompanyVehicle_NUM_Description) */

int zx_hrxml_CompanyVehicle_NUM_Description(struct zx_hrxml_CompanyVehicle_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompanyVehicle_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_CompanyVehicle_GET_Description(struct zx_hrxml_CompanyVehicle_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompanyVehicle_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_CompanyVehicle_POP_Description(struct zx_hrxml_CompanyVehicle_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompanyVehicle_PUSH_Description) */

void zx_hrxml_CompanyVehicle_PUSH_Description(struct zx_hrxml_CompanyVehicle_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_CompanyVehicle_REV_Description) */

void zx_hrxml_CompanyVehicle_REV_Description(struct zx_hrxml_CompanyVehicle_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompanyVehicle_PUT_Description) */

void zx_hrxml_CompanyVehicle_PUT_Description(struct zx_hrxml_CompanyVehicle_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompanyVehicle_ADD_Description) */

void zx_hrxml_CompanyVehicle_ADD_Description(struct zx_hrxml_CompanyVehicle_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompanyVehicle_DEL_Description) */

void zx_hrxml_CompanyVehicle_DEL_Description(struct zx_hrxml_CompanyVehicle_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_CompanyVehicle_GET_companyOffered) */
struct zx_str* zx_hrxml_CompanyVehicle_GET_companyOffered(struct zx_hrxml_CompanyVehicle_s* x) { return x->companyOffered; }
/* FUNC(zx_hrxml_CompanyVehicle_PUT_companyOffered) */
void zx_hrxml_CompanyVehicle_PUT_companyOffered(struct zx_hrxml_CompanyVehicle_s* x, struct zx_str* y) { x->companyOffered = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Compensation_NUM_StartingCompensation) */

int zx_hrxml_Compensation_NUM_StartingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_StartingCompensation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartingCompensation; y; ++n, y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Compensation_GET_StartingCompensation) */

struct zx_hrxml_StartingCompensation_s* zx_hrxml_Compensation_GET_StartingCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x) return 0;
  for (y = x->StartingCompensation; n>=0 && y; --n, y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Compensation_POP_StartingCompensation) */

struct zx_hrxml_StartingCompensation_s* zx_hrxml_Compensation_POP_StartingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x) return 0;
  y = x->StartingCompensation;
  if (y)
    x->StartingCompensation = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Compensation_PUSH_StartingCompensation) */

void zx_hrxml_Compensation_PUSH_StartingCompensation(struct zx_hrxml_Compensation_s* x, struct zx_hrxml_StartingCompensation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartingCompensation->gg.g;
  x->StartingCompensation = z;
}

/* FUNC(zx_hrxml_Compensation_REV_StartingCompensation) */

void zx_hrxml_Compensation_REV_StartingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_StartingCompensation_s* nxt;
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x) return;
  y = x->StartingCompensation;
  if (!y) return;
  x->StartingCompensation = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n;
    y->gg.g.n = &x->StartingCompensation->gg.g;
    x->StartingCompensation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Compensation_PUT_StartingCompensation) */

void zx_hrxml_Compensation_PUT_StartingCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_StartingCompensation_s* z)
{
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x || !z) return;
  y = x->StartingCompensation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartingCompensation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Compensation_ADD_StartingCompensation) */

void zx_hrxml_Compensation_ADD_StartingCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_StartingCompensation_s* z)
{
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartingCompensation->gg.g;
    x->StartingCompensation = z;
    return;
  case -1:
    y = x->StartingCompensation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartingCompensation; n > 1 && y; --n, y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Compensation_DEL_StartingCompensation) */

void zx_hrxml_Compensation_DEL_StartingCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_StartingCompensation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartingCompensation = (struct zx_hrxml_StartingCompensation_s*)x->StartingCompensation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartingCompensation_s*)x->StartingCompensation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartingCompensation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartingCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Compensation_NUM_EndingCompensation) */

int zx_hrxml_Compensation_NUM_EndingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_EndingCompensation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndingCompensation; y; ++n, y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Compensation_GET_EndingCompensation) */

struct zx_hrxml_EndingCompensation_s* zx_hrxml_Compensation_GET_EndingCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x) return 0;
  for (y = x->EndingCompensation; n>=0 && y; --n, y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Compensation_POP_EndingCompensation) */

struct zx_hrxml_EndingCompensation_s* zx_hrxml_Compensation_POP_EndingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x) return 0;
  y = x->EndingCompensation;
  if (y)
    x->EndingCompensation = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Compensation_PUSH_EndingCompensation) */

void zx_hrxml_Compensation_PUSH_EndingCompensation(struct zx_hrxml_Compensation_s* x, struct zx_hrxml_EndingCompensation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndingCompensation->gg.g;
  x->EndingCompensation = z;
}

/* FUNC(zx_hrxml_Compensation_REV_EndingCompensation) */

void zx_hrxml_Compensation_REV_EndingCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_EndingCompensation_s* nxt;
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x) return;
  y = x->EndingCompensation;
  if (!y) return;
  x->EndingCompensation = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n;
    y->gg.g.n = &x->EndingCompensation->gg.g;
    x->EndingCompensation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Compensation_PUT_EndingCompensation) */

void zx_hrxml_Compensation_PUT_EndingCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_EndingCompensation_s* z)
{
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x || !z) return;
  y = x->EndingCompensation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndingCompensation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Compensation_ADD_EndingCompensation) */

void zx_hrxml_Compensation_ADD_EndingCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_EndingCompensation_s* z)
{
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndingCompensation->gg.g;
    x->EndingCompensation = z;
    return;
  case -1:
    y = x->EndingCompensation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndingCompensation; n > 1 && y; --n, y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Compensation_DEL_EndingCompensation) */

void zx_hrxml_Compensation_DEL_EndingCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_EndingCompensation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndingCompensation = (struct zx_hrxml_EndingCompensation_s*)x->EndingCompensation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndingCompensation_s*)x->EndingCompensation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndingCompensation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndingCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Compensation_NUM_Comments) */

int zx_hrxml_Compensation_NUM_Comments(struct zx_hrxml_Compensation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Compensation_GET_Comments) */

struct zx_elem_s* zx_hrxml_Compensation_GET_Comments(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Compensation_POP_Comments) */

struct zx_elem_s* zx_hrxml_Compensation_POP_Comments(struct zx_hrxml_Compensation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Compensation_PUSH_Comments) */

void zx_hrxml_Compensation_PUSH_Comments(struct zx_hrxml_Compensation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Compensation_REV_Comments) */

void zx_hrxml_Compensation_REV_Comments(struct zx_hrxml_Compensation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Compensation_PUT_Comments) */

void zx_hrxml_Compensation_PUT_Comments(struct zx_hrxml_Compensation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Compensation_ADD_Comments) */

void zx_hrxml_Compensation_ADD_Comments(struct zx_hrxml_Compensation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Compensation_DEL_Comments) */

void zx_hrxml_Compensation_DEL_Comments(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Compensation_NUM_OtherCompensation) */

int zx_hrxml_Compensation_NUM_OtherCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_OtherCompensation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherCompensation; y; ++n, y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Compensation_GET_OtherCompensation) */

struct zx_hrxml_OtherCompensation_s* zx_hrxml_Compensation_GET_OtherCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x) return 0;
  for (y = x->OtherCompensation; n>=0 && y; --n, y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Compensation_POP_OtherCompensation) */

struct zx_hrxml_OtherCompensation_s* zx_hrxml_Compensation_POP_OtherCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x) return 0;
  y = x->OtherCompensation;
  if (y)
    x->OtherCompensation = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Compensation_PUSH_OtherCompensation) */

void zx_hrxml_Compensation_PUSH_OtherCompensation(struct zx_hrxml_Compensation_s* x, struct zx_hrxml_OtherCompensation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherCompensation->gg.g;
  x->OtherCompensation = z;
}

/* FUNC(zx_hrxml_Compensation_REV_OtherCompensation) */

void zx_hrxml_Compensation_REV_OtherCompensation(struct zx_hrxml_Compensation_s* x)
{
  struct zx_hrxml_OtherCompensation_s* nxt;
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x) return;
  y = x->OtherCompensation;
  if (!y) return;
  x->OtherCompensation = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherCompensation->gg.g;
    x->OtherCompensation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Compensation_PUT_OtherCompensation) */

void zx_hrxml_Compensation_PUT_OtherCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_OtherCompensation_s* z)
{
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x || !z) return;
  y = x->OtherCompensation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherCompensation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Compensation_ADD_OtherCompensation) */

void zx_hrxml_Compensation_ADD_OtherCompensation(struct zx_hrxml_Compensation_s* x, int n, struct zx_hrxml_OtherCompensation_s* z)
{
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherCompensation->gg.g;
    x->OtherCompensation = z;
    return;
  case -1:
    y = x->OtherCompensation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherCompensation; n > 1 && y; --n, y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Compensation_DEL_OtherCompensation) */

void zx_hrxml_Compensation_DEL_OtherCompensation(struct zx_hrxml_Compensation_s* x, int n)
{
  struct zx_hrxml_OtherCompensation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherCompensation = (struct zx_hrxml_OtherCompensation_s*)x->OtherCompensation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherCompensation_s*)x->OtherCompensation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherCompensation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherCompensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_CompetencyId) */

int zx_hrxml_Competency_NUM_CompetencyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompetencyId; y; ++n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_CompetencyId) */

struct zx_hrxml_CompetencyId_s* zx_hrxml_Competency_GET_CompetencyId(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return 0;
  for (y = x->CompetencyId; n>=0 && y; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_CompetencyId) */

struct zx_hrxml_CompetencyId_s* zx_hrxml_Competency_POP_CompetencyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return 0;
  y = x->CompetencyId;
  if (y)
    x->CompetencyId = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_CompetencyId) */

void zx_hrxml_Competency_PUSH_CompetencyId(struct zx_hrxml_Competency_s* x, struct zx_hrxml_CompetencyId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CompetencyId->gg.g;
  x->CompetencyId = z;
}

/* FUNC(zx_hrxml_Competency_REV_CompetencyId) */

void zx_hrxml_Competency_REV_CompetencyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyId_s* nxt;
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return;
  y = x->CompetencyId;
  if (!y) return;
  x->CompetencyId = 0;
  while (y) {
    nxt = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n;
    y->gg.g.n = &x->CompetencyId->gg.g;
    x->CompetencyId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_CompetencyId) */

void zx_hrxml_Competency_PUT_CompetencyId(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyId_s* z)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x || !z) return;
  y = x->CompetencyId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CompetencyId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_CompetencyId) */

void zx_hrxml_Competency_ADD_CompetencyId(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyId_s* z)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CompetencyId->gg.g;
    x->CompetencyId = z;
    return;
  case -1:
    y = x->CompetencyId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyId; n > 1 && y; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_CompetencyId) */

void zx_hrxml_Competency_DEL_CompetencyId(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompetencyId = (struct zx_hrxml_CompetencyId_s*)x->CompetencyId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CompetencyId_s*)x->CompetencyId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_TaxonomyId) */

int zx_hrxml_Competency_NUM_TaxonomyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_TaxonomyId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TaxonomyId; y; ++n, y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_TaxonomyId) */

struct zx_hrxml_TaxonomyId_s* zx_hrxml_Competency_GET_TaxonomyId(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x) return 0;
  for (y = x->TaxonomyId; n>=0 && y; --n, y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_TaxonomyId) */

struct zx_hrxml_TaxonomyId_s* zx_hrxml_Competency_POP_TaxonomyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x) return 0;
  y = x->TaxonomyId;
  if (y)
    x->TaxonomyId = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_TaxonomyId) */

void zx_hrxml_Competency_PUSH_TaxonomyId(struct zx_hrxml_Competency_s* x, struct zx_hrxml_TaxonomyId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TaxonomyId->gg.g;
  x->TaxonomyId = z;
}

/* FUNC(zx_hrxml_Competency_REV_TaxonomyId) */

void zx_hrxml_Competency_REV_TaxonomyId(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_TaxonomyId_s* nxt;
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x) return;
  y = x->TaxonomyId;
  if (!y) return;
  x->TaxonomyId = 0;
  while (y) {
    nxt = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n;
    y->gg.g.n = &x->TaxonomyId->gg.g;
    x->TaxonomyId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_TaxonomyId) */

void zx_hrxml_Competency_PUT_TaxonomyId(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_TaxonomyId_s* z)
{
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x || !z) return;
  y = x->TaxonomyId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TaxonomyId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_TaxonomyId) */

void zx_hrxml_Competency_ADD_TaxonomyId(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_TaxonomyId_s* z)
{
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TaxonomyId->gg.g;
    x->TaxonomyId = z;
    return;
  case -1:
    y = x->TaxonomyId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxonomyId; n > 1 && y; --n, y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_TaxonomyId) */

void zx_hrxml_Competency_DEL_TaxonomyId(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_TaxonomyId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TaxonomyId = (struct zx_hrxml_TaxonomyId_s*)x->TaxonomyId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TaxonomyId_s*)x->TaxonomyId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxonomyId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxonomyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_CompetencyEvidence) */

int zx_hrxml_Competency_NUM_CompetencyEvidence(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompetencyEvidence; y; ++n, y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_CompetencyEvidence) */

struct zx_hrxml_CompetencyEvidence_s* zx_hrxml_Competency_GET_CompetencyEvidence(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x) return 0;
  for (y = x->CompetencyEvidence; n>=0 && y; --n, y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_CompetencyEvidence) */

struct zx_hrxml_CompetencyEvidence_s* zx_hrxml_Competency_POP_CompetencyEvidence(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x) return 0;
  y = x->CompetencyEvidence;
  if (y)
    x->CompetencyEvidence = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_CompetencyEvidence) */

void zx_hrxml_Competency_PUSH_CompetencyEvidence(struct zx_hrxml_Competency_s* x, struct zx_hrxml_CompetencyEvidence_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CompetencyEvidence->gg.g;
  x->CompetencyEvidence = z;
}

/* FUNC(zx_hrxml_Competency_REV_CompetencyEvidence) */

void zx_hrxml_Competency_REV_CompetencyEvidence(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyEvidence_s* nxt;
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x) return;
  y = x->CompetencyEvidence;
  if (!y) return;
  x->CompetencyEvidence = 0;
  while (y) {
    nxt = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n;
    y->gg.g.n = &x->CompetencyEvidence->gg.g;
    x->CompetencyEvidence = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_CompetencyEvidence) */

void zx_hrxml_Competency_PUT_CompetencyEvidence(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyEvidence_s* z)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x || !z) return;
  y = x->CompetencyEvidence;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CompetencyEvidence = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_CompetencyEvidence) */

void zx_hrxml_Competency_ADD_CompetencyEvidence(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyEvidence_s* z)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CompetencyEvidence->gg.g;
    x->CompetencyEvidence = z;
    return;
  case -1:
    y = x->CompetencyEvidence;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyEvidence; n > 1 && y; --n, y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_CompetencyEvidence) */

void zx_hrxml_Competency_DEL_CompetencyEvidence(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyEvidence_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompetencyEvidence = (struct zx_hrxml_CompetencyEvidence_s*)x->CompetencyEvidence->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CompetencyEvidence_s*)x->CompetencyEvidence;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyEvidence; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyEvidence_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_CompetencyWeight) */

int zx_hrxml_Competency_NUM_CompetencyWeight(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompetencyWeight; y; ++n, y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_CompetencyWeight) */

struct zx_hrxml_CompetencyWeight_s* zx_hrxml_Competency_GET_CompetencyWeight(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x) return 0;
  for (y = x->CompetencyWeight; n>=0 && y; --n, y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_CompetencyWeight) */

struct zx_hrxml_CompetencyWeight_s* zx_hrxml_Competency_POP_CompetencyWeight(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x) return 0;
  y = x->CompetencyWeight;
  if (y)
    x->CompetencyWeight = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_CompetencyWeight) */

void zx_hrxml_Competency_PUSH_CompetencyWeight(struct zx_hrxml_Competency_s* x, struct zx_hrxml_CompetencyWeight_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CompetencyWeight->gg.g;
  x->CompetencyWeight = z;
}

/* FUNC(zx_hrxml_Competency_REV_CompetencyWeight) */

void zx_hrxml_Competency_REV_CompetencyWeight(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_CompetencyWeight_s* nxt;
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x) return;
  y = x->CompetencyWeight;
  if (!y) return;
  x->CompetencyWeight = 0;
  while (y) {
    nxt = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n;
    y->gg.g.n = &x->CompetencyWeight->gg.g;
    x->CompetencyWeight = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_CompetencyWeight) */

void zx_hrxml_Competency_PUT_CompetencyWeight(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyWeight_s* z)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x || !z) return;
  y = x->CompetencyWeight;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CompetencyWeight = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_CompetencyWeight) */

void zx_hrxml_Competency_ADD_CompetencyWeight(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_CompetencyWeight_s* z)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CompetencyWeight->gg.g;
    x->CompetencyWeight = z;
    return;
  case -1:
    y = x->CompetencyWeight;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyWeight; n > 1 && y; --n, y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_CompetencyWeight) */

void zx_hrxml_Competency_DEL_CompetencyWeight(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_CompetencyWeight_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompetencyWeight = (struct zx_hrxml_CompetencyWeight_s*)x->CompetencyWeight->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CompetencyWeight_s*)x->CompetencyWeight;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyWeight; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyWeight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_Competency) */

int zx_hrxml_Competency_NUM_Competency(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_Competency_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Competency; y; ++n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_Competency_GET_Competency(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  for (y = x->Competency; n>=0 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_Competency_POP_Competency(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  y = x->Competency;
  if (y)
    x->Competency = (struct zx_hrxml_Competency_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_Competency) */

void zx_hrxml_Competency_PUSH_Competency(struct zx_hrxml_Competency_s* x, struct zx_hrxml_Competency_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Competency->gg.g;
  x->Competency = z;
}

/* FUNC(zx_hrxml_Competency_REV_Competency) */

void zx_hrxml_Competency_REV_Competency(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_Competency_s* nxt;
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  y = x->Competency;
  if (!y) return;
  x->Competency = 0;
  while (y) {
    nxt = (struct zx_hrxml_Competency_s*)y->gg.g.n;
    y->gg.g.n = &x->Competency->gg.g;
    x->Competency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_Competency) */

void zx_hrxml_Competency_PUT_Competency(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  y = x->Competency;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Competency = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_Competency) */

void zx_hrxml_Competency_ADD_Competency(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Competency->gg.g;
    x->Competency = z;
    return;
  case -1:
    y = x->Competency;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_Competency) */

void zx_hrxml_Competency_DEL_Competency(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Competency = (struct zx_hrxml_Competency_s*)x->Competency->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Competency_s*)x->Competency;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Competency_NUM_UserArea) */

int zx_hrxml_Competency_NUM_UserArea(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Competency_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Competency_GET_UserArea(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Competency_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Competency_POP_UserArea(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Competency_PUSH_UserArea) */

void zx_hrxml_Competency_PUSH_UserArea(struct zx_hrxml_Competency_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_Competency_REV_UserArea) */

void zx_hrxml_Competency_REV_UserArea(struct zx_hrxml_Competency_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Competency_PUT_UserArea) */

void zx_hrxml_Competency_PUT_UserArea(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Competency_ADD_UserArea) */

void zx_hrxml_Competency_ADD_UserArea(struct zx_hrxml_Competency_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Competency_DEL_UserArea) */

void zx_hrxml_Competency_DEL_UserArea(struct zx_hrxml_Competency_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Competency_GET_description) */
struct zx_str* zx_hrxml_Competency_GET_description(struct zx_hrxml_Competency_s* x) { return x->description; }
/* FUNC(zx_hrxml_Competency_PUT_description) */
void zx_hrxml_Competency_PUT_description(struct zx_hrxml_Competency_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_Competency_GET_name) */
struct zx_str* zx_hrxml_Competency_GET_name(struct zx_hrxml_Competency_s* x) { return x->name; }
/* FUNC(zx_hrxml_Competency_PUT_name) */
void zx_hrxml_Competency_PUT_name(struct zx_hrxml_Competency_s* x, struct zx_str* y) { x->name = y; }
/* FUNC(zx_hrxml_Competency_GET_required) */
struct zx_str* zx_hrxml_Competency_GET_required(struct zx_hrxml_Competency_s* x) { return x->required; }
/* FUNC(zx_hrxml_Competency_PUT_required) */
void zx_hrxml_Competency_PUT_required(struct zx_hrxml_Competency_s* x, struct zx_str* y) { x->required = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyEvidence_NUM_EvidenceId) */

int zx_hrxml_CompetencyEvidence_NUM_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_EvidenceId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EvidenceId; y; ++n, y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyEvidence_GET_EvidenceId) */

struct zx_hrxml_EvidenceId_s* zx_hrxml_CompetencyEvidence_GET_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_EvidenceId_s* y;
  if (!x) return 0;
  for (y = x->EvidenceId; n>=0 && y; --n, y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_POP_EvidenceId) */

struct zx_hrxml_EvidenceId_s* zx_hrxml_CompetencyEvidence_POP_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_EvidenceId_s* y;
  if (!x) return 0;
  y = x->EvidenceId;
  if (y)
    x->EvidenceId = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUSH_EvidenceId) */

void zx_hrxml_CompetencyEvidence_PUSH_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_hrxml_EvidenceId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EvidenceId->gg.g;
  x->EvidenceId = z;
}

/* FUNC(zx_hrxml_CompetencyEvidence_REV_EvidenceId) */

void zx_hrxml_CompetencyEvidence_REV_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_EvidenceId_s* nxt;
  struct zx_hrxml_EvidenceId_s* y;
  if (!x) return;
  y = x->EvidenceId;
  if (!y) return;
  x->EvidenceId = 0;
  while (y) {
    nxt = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n;
    y->gg.g.n = &x->EvidenceId->gg.g;
    x->EvidenceId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUT_EvidenceId) */

void zx_hrxml_CompetencyEvidence_PUT_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_EvidenceId_s* z)
{
  struct zx_hrxml_EvidenceId_s* y;
  if (!x || !z) return;
  y = x->EvidenceId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EvidenceId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_ADD_EvidenceId) */

void zx_hrxml_CompetencyEvidence_ADD_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_EvidenceId_s* z)
{
  struct zx_hrxml_EvidenceId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EvidenceId->gg.g;
    x->EvidenceId = z;
    return;
  case -1:
    y = x->EvidenceId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EvidenceId; n > 1 && y; --n, y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyEvidence_DEL_EvidenceId) */

void zx_hrxml_CompetencyEvidence_DEL_EvidenceId(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_EvidenceId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EvidenceId = (struct zx_hrxml_EvidenceId_s*)x->EvidenceId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EvidenceId_s*)x->EvidenceId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EvidenceId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EvidenceId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyEvidence_NUM_NumericValue) */

int zx_hrxml_CompetencyEvidence_NUM_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumericValue; y; ++n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyEvidence_GET_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_CompetencyEvidence_GET_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  for (y = x->NumericValue; n>=0 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_POP_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_CompetencyEvidence_POP_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  y = x->NumericValue;
  if (y)
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUSH_NumericValue) */

void zx_hrxml_CompetencyEvidence_PUSH_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_hrxml_NumericValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->NumericValue->gg.g;
  x->NumericValue = z;
}

/* FUNC(zx_hrxml_CompetencyEvidence_REV_NumericValue) */

void zx_hrxml_CompetencyEvidence_REV_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_NumericValue_s* nxt;
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  y = x->NumericValue;
  if (!y) return;
  x->NumericValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
    y->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUT_NumericValue) */

void zx_hrxml_CompetencyEvidence_PUT_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  y = x->NumericValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->NumericValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_ADD_NumericValue) */

void zx_hrxml_CompetencyEvidence_ADD_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = z;
    return;
  case -1:
    y = x->NumericValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyEvidence_DEL_NumericValue) */

void zx_hrxml_CompetencyEvidence_DEL_NumericValue(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)x->NumericValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_NumericValue_s*)x->NumericValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyEvidence_NUM_StringValue) */

int zx_hrxml_CompetencyEvidence_NUM_StringValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringValue; y; ++n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyEvidence_GET_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_CompetencyEvidence_GET_StringValue(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  for (y = x->StringValue; n>=0 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_POP_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_CompetencyEvidence_POP_StringValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  y = x->StringValue;
  if (y)
    x->StringValue = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUSH_StringValue) */

void zx_hrxml_CompetencyEvidence_PUSH_StringValue(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_hrxml_StringValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StringValue->gg.g;
  x->StringValue = z;
}

/* FUNC(zx_hrxml_CompetencyEvidence_REV_StringValue) */

void zx_hrxml_CompetencyEvidence_REV_StringValue(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_hrxml_StringValue_s* nxt;
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  y = x->StringValue;
  if (!y) return;
  x->StringValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
    y->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUT_StringValue) */

void zx_hrxml_CompetencyEvidence_PUT_StringValue(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  y = x->StringValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StringValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_ADD_StringValue) */

void zx_hrxml_CompetencyEvidence_ADD_StringValue(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = z;
    return;
  case -1:
    y = x->StringValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyEvidence_DEL_StringValue) */

void zx_hrxml_CompetencyEvidence_DEL_StringValue(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringValue = (struct zx_hrxml_StringValue_s*)x->StringValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StringValue_s*)x->StringValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyEvidence_NUM_SupportingInformation) */

int zx_hrxml_CompetencyEvidence_NUM_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingInformation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyEvidence_GET_SupportingInformation) */

struct zx_elem_s* zx_hrxml_CompetencyEvidence_GET_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SupportingInformation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_POP_SupportingInformation) */

struct zx_elem_s* zx_hrxml_CompetencyEvidence_POP_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SupportingInformation;
  if (y)
    x->SupportingInformation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUSH_SupportingInformation) */

void zx_hrxml_CompetencyEvidence_PUSH_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SupportingInformation->g;
  x->SupportingInformation = z;
}

/* FUNC(zx_hrxml_CompetencyEvidence_REV_SupportingInformation) */

void zx_hrxml_CompetencyEvidence_REV_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SupportingInformation;
  if (!y) return;
  x->SupportingInformation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SupportingInformation->g;
    x->SupportingInformation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_PUT_SupportingInformation) */

void zx_hrxml_CompetencyEvidence_PUT_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SupportingInformation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SupportingInformation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_CompetencyEvidence_ADD_SupportingInformation) */

void zx_hrxml_CompetencyEvidence_ADD_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SupportingInformation->g;
    x->SupportingInformation = z;
    return;
  case -1:
    y = x->SupportingInformation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SupportingInformation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_CompetencyEvidence_DEL_SupportingInformation) */

void zx_hrxml_CompetencyEvidence_DEL_SupportingInformation(struct zx_hrxml_CompetencyEvidence_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingInformation = (struct zx_elem_s*)x->SupportingInformation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SupportingInformation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SupportingInformation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_CompetencyEvidence_GET_dateOfIncident) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_dateOfIncident(struct zx_hrxml_CompetencyEvidence_s* x) { return x->dateOfIncident; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_dateOfIncident) */
void zx_hrxml_CompetencyEvidence_PUT_dateOfIncident(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->dateOfIncident = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_expirationDate) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_expirationDate(struct zx_hrxml_CompetencyEvidence_s* x) { return x->expirationDate; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_expirationDate) */
void zx_hrxml_CompetencyEvidence_PUT_expirationDate(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->expirationDate = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_lastUsed) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_lastUsed(struct zx_hrxml_CompetencyEvidence_s* x) { return x->lastUsed; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_lastUsed) */
void zx_hrxml_CompetencyEvidence_PUT_lastUsed(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->lastUsed = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_name) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_name(struct zx_hrxml_CompetencyEvidence_s* x) { return x->name; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_name) */
void zx_hrxml_CompetencyEvidence_PUT_name(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->name = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_required) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_required(struct zx_hrxml_CompetencyEvidence_s* x) { return x->required; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_required) */
void zx_hrxml_CompetencyEvidence_PUT_required(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->required = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_typeDescription) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_typeDescription(struct zx_hrxml_CompetencyEvidence_s* x) { return x->typeDescription; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_typeDescription) */
void zx_hrxml_CompetencyEvidence_PUT_typeDescription(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->typeDescription = y; }
/* FUNC(zx_hrxml_CompetencyEvidence_GET_typeId) */
struct zx_str* zx_hrxml_CompetencyEvidence_GET_typeId(struct zx_hrxml_CompetencyEvidence_s* x) { return x->typeId; }
/* FUNC(zx_hrxml_CompetencyEvidence_PUT_typeId) */
void zx_hrxml_CompetencyEvidence_PUT_typeId(struct zx_hrxml_CompetencyEvidence_s* x, struct zx_str* y) { x->typeId = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyId_NUM_IdValue) */

int zx_hrxml_CompetencyId_NUM_IdValue(struct zx_hrxml_CompetencyId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_CompetencyId_GET_IdValue(struct zx_hrxml_CompetencyId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_CompetencyId_POP_IdValue(struct zx_hrxml_CompetencyId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyId_PUSH_IdValue) */

void zx_hrxml_CompetencyId_PUSH_IdValue(struct zx_hrxml_CompetencyId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_CompetencyId_REV_IdValue) */

void zx_hrxml_CompetencyId_REV_IdValue(struct zx_hrxml_CompetencyId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyId_PUT_IdValue) */

void zx_hrxml_CompetencyId_PUT_IdValue(struct zx_hrxml_CompetencyId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyId_ADD_IdValue) */

void zx_hrxml_CompetencyId_ADD_IdValue(struct zx_hrxml_CompetencyId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyId_DEL_IdValue) */

void zx_hrxml_CompetencyId_DEL_IdValue(struct zx_hrxml_CompetencyId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_CompetencyId_GET_idOwner) */
struct zx_str* zx_hrxml_CompetencyId_GET_idOwner(struct zx_hrxml_CompetencyId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_CompetencyId_PUT_idOwner) */
void zx_hrxml_CompetencyId_PUT_idOwner(struct zx_hrxml_CompetencyId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_CompetencyId_GET_validFrom) */
struct zx_str* zx_hrxml_CompetencyId_GET_validFrom(struct zx_hrxml_CompetencyId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_CompetencyId_PUT_validFrom) */
void zx_hrxml_CompetencyId_PUT_validFrom(struct zx_hrxml_CompetencyId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_CompetencyId_GET_validTo) */
struct zx_str* zx_hrxml_CompetencyId_GET_validTo(struct zx_hrxml_CompetencyId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_CompetencyId_PUT_validTo) */
void zx_hrxml_CompetencyId_PUT_validTo(struct zx_hrxml_CompetencyId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyWeight_NUM_NumericValue) */

int zx_hrxml_CompetencyWeight_NUM_NumericValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumericValue; y; ++n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyWeight_GET_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_CompetencyWeight_GET_NumericValue(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  for (y = x->NumericValue; n>=0 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_POP_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_CompetencyWeight_POP_NumericValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  y = x->NumericValue;
  if (y)
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_PUSH_NumericValue) */

void zx_hrxml_CompetencyWeight_PUSH_NumericValue(struct zx_hrxml_CompetencyWeight_s* x, struct zx_hrxml_NumericValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->NumericValue->gg.g;
  x->NumericValue = z;
}

/* FUNC(zx_hrxml_CompetencyWeight_REV_NumericValue) */

void zx_hrxml_CompetencyWeight_REV_NumericValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_NumericValue_s* nxt;
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  y = x->NumericValue;
  if (!y) return;
  x->NumericValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
    y->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_PUT_NumericValue) */

void zx_hrxml_CompetencyWeight_PUT_NumericValue(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  y = x->NumericValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->NumericValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_ADD_NumericValue) */

void zx_hrxml_CompetencyWeight_ADD_NumericValue(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = z;
    return;
  case -1:
    y = x->NumericValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyWeight_DEL_NumericValue) */

void zx_hrxml_CompetencyWeight_DEL_NumericValue(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)x->NumericValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_NumericValue_s*)x->NumericValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyWeight_NUM_StringValue) */

int zx_hrxml_CompetencyWeight_NUM_StringValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringValue; y; ++n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyWeight_GET_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_CompetencyWeight_GET_StringValue(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  for (y = x->StringValue; n>=0 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_POP_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_CompetencyWeight_POP_StringValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  y = x->StringValue;
  if (y)
    x->StringValue = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_PUSH_StringValue) */

void zx_hrxml_CompetencyWeight_PUSH_StringValue(struct zx_hrxml_CompetencyWeight_s* x, struct zx_hrxml_StringValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StringValue->gg.g;
  x->StringValue = z;
}

/* FUNC(zx_hrxml_CompetencyWeight_REV_StringValue) */

void zx_hrxml_CompetencyWeight_REV_StringValue(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_hrxml_StringValue_s* nxt;
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  y = x->StringValue;
  if (!y) return;
  x->StringValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
    y->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_PUT_StringValue) */

void zx_hrxml_CompetencyWeight_PUT_StringValue(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  y = x->StringValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StringValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_ADD_StringValue) */

void zx_hrxml_CompetencyWeight_ADD_StringValue(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = z;
    return;
  case -1:
    y = x->StringValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CompetencyWeight_DEL_StringValue) */

void zx_hrxml_CompetencyWeight_DEL_StringValue(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringValue = (struct zx_hrxml_StringValue_s*)x->StringValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StringValue_s*)x->StringValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CompetencyWeight_NUM_SupportingInformation) */

int zx_hrxml_CompetencyWeight_NUM_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingInformation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CompetencyWeight_GET_SupportingInformation) */

struct zx_elem_s* zx_hrxml_CompetencyWeight_GET_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SupportingInformation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_POP_SupportingInformation) */

struct zx_elem_s* zx_hrxml_CompetencyWeight_POP_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SupportingInformation;
  if (y)
    x->SupportingInformation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_CompetencyWeight_PUSH_SupportingInformation) */

void zx_hrxml_CompetencyWeight_PUSH_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SupportingInformation->g;
  x->SupportingInformation = z;
}

/* FUNC(zx_hrxml_CompetencyWeight_REV_SupportingInformation) */

void zx_hrxml_CompetencyWeight_REV_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SupportingInformation;
  if (!y) return;
  x->SupportingInformation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SupportingInformation->g;
    x->SupportingInformation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_PUT_SupportingInformation) */

void zx_hrxml_CompetencyWeight_PUT_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SupportingInformation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SupportingInformation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_CompetencyWeight_ADD_SupportingInformation) */

void zx_hrxml_CompetencyWeight_ADD_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SupportingInformation->g;
    x->SupportingInformation = z;
    return;
  case -1:
    y = x->SupportingInformation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SupportingInformation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_CompetencyWeight_DEL_SupportingInformation) */

void zx_hrxml_CompetencyWeight_DEL_SupportingInformation(struct zx_hrxml_CompetencyWeight_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingInformation = (struct zx_elem_s*)x->SupportingInformation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SupportingInformation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SupportingInformation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_CompetencyWeight_GET_type) */
struct zx_str* zx_hrxml_CompetencyWeight_GET_type(struct zx_hrxml_CompetencyWeight_s* x) { return x->type; }
/* FUNC(zx_hrxml_CompetencyWeight_PUT_type) */
void zx_hrxml_CompetencyWeight_PUT_type(struct zx_hrxml_CompetencyWeight_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferenceDate_NUM_AnyDate) */

int zx_hrxml_ConferenceDate_NUM_AnyDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferenceDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_ConferenceDate_GET_AnyDate(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_ConferenceDate_POP_AnyDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_PUSH_AnyDate) */

void zx_hrxml_ConferenceDate_PUSH_AnyDate(struct zx_hrxml_ConferenceDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_ConferenceDate_REV_AnyDate) */

void zx_hrxml_ConferenceDate_REV_AnyDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_PUT_AnyDate) */

void zx_hrxml_ConferenceDate_PUT_AnyDate(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_ADD_AnyDate) */

void zx_hrxml_ConferenceDate_ADD_AnyDate(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferenceDate_DEL_AnyDate) */

void zx_hrxml_ConferenceDate_DEL_AnyDate(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferenceDate_NUM_YearMonth) */

int zx_hrxml_ConferenceDate_NUM_YearMonth(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferenceDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_ConferenceDate_GET_YearMonth(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_ConferenceDate_POP_YearMonth(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_PUSH_YearMonth) */

void zx_hrxml_ConferenceDate_PUSH_YearMonth(struct zx_hrxml_ConferenceDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_ConferenceDate_REV_YearMonth) */

void zx_hrxml_ConferenceDate_REV_YearMonth(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_PUT_YearMonth) */

void zx_hrxml_ConferenceDate_PUT_YearMonth(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_ADD_YearMonth) */

void zx_hrxml_ConferenceDate_ADD_YearMonth(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferenceDate_DEL_YearMonth) */

void zx_hrxml_ConferenceDate_DEL_YearMonth(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferenceDate_NUM_Year) */

int zx_hrxml_ConferenceDate_NUM_Year(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferenceDate_GET_Year) */

struct zx_elem_s* zx_hrxml_ConferenceDate_GET_Year(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_POP_Year) */

struct zx_elem_s* zx_hrxml_ConferenceDate_POP_Year(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_PUSH_Year) */

void zx_hrxml_ConferenceDate_PUSH_Year(struct zx_hrxml_ConferenceDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_ConferenceDate_REV_Year) */

void zx_hrxml_ConferenceDate_REV_Year(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_PUT_Year) */

void zx_hrxml_ConferenceDate_PUT_Year(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_ADD_Year) */

void zx_hrxml_ConferenceDate_ADD_Year(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferenceDate_DEL_Year) */

void zx_hrxml_ConferenceDate_DEL_Year(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferenceDate_NUM_MonthDay) */

int zx_hrxml_ConferenceDate_NUM_MonthDay(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferenceDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_ConferenceDate_GET_MonthDay(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_ConferenceDate_POP_MonthDay(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_PUSH_MonthDay) */

void zx_hrxml_ConferenceDate_PUSH_MonthDay(struct zx_hrxml_ConferenceDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_ConferenceDate_REV_MonthDay) */

void zx_hrxml_ConferenceDate_REV_MonthDay(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_PUT_MonthDay) */

void zx_hrxml_ConferenceDate_PUT_MonthDay(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_ADD_MonthDay) */

void zx_hrxml_ConferenceDate_ADD_MonthDay(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferenceDate_DEL_MonthDay) */

void zx_hrxml_ConferenceDate_DEL_MonthDay(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferenceDate_NUM_StringDate) */

int zx_hrxml_ConferenceDate_NUM_StringDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferenceDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_ConferenceDate_GET_StringDate(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_ConferenceDate_POP_StringDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferenceDate_PUSH_StringDate) */

void zx_hrxml_ConferenceDate_PUSH_StringDate(struct zx_hrxml_ConferenceDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_ConferenceDate_REV_StringDate) */

void zx_hrxml_ConferenceDate_REV_StringDate(struct zx_hrxml_ConferenceDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_PUT_StringDate) */

void zx_hrxml_ConferenceDate_PUT_StringDate(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferenceDate_ADD_StringDate) */

void zx_hrxml_ConferenceDate_ADD_StringDate(struct zx_hrxml_ConferenceDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferenceDate_DEL_StringDate) */

void zx_hrxml_ConferenceDate_DEL_StringDate(struct zx_hrxml_ConferenceDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_ConferenceDate_GET_dateDescription) */
struct zx_str* zx_hrxml_ConferenceDate_GET_dateDescription(struct zx_hrxml_ConferenceDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_ConferenceDate_PUT_dateDescription) */
void zx_hrxml_ConferenceDate_PUT_dateDescription(struct zx_hrxml_ConferenceDate_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Title) */

int zx_hrxml_ConferencePaper_NUM_Title(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Title) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_Title(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Title) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_Title(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Title) */

void zx_hrxml_ConferencePaper_PUSH_Title(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Title) */

void zx_hrxml_ConferencePaper_REV_Title(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Title) */

void zx_hrxml_ConferencePaper_PUT_Title(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Title) */

void zx_hrxml_ConferencePaper_ADD_Title(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Title) */

void zx_hrxml_ConferencePaper_DEL_Title(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Name) */

int zx_hrxml_ConferencePaper_NUM_Name(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Name) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_Name(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Name) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_Name(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Name) */

void zx_hrxml_ConferencePaper_PUSH_Name(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Name) */

void zx_hrxml_ConferencePaper_REV_Name(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Name) */

void zx_hrxml_ConferencePaper_PUT_Name(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Name) */

void zx_hrxml_ConferencePaper_ADD_Name(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Name) */

void zx_hrxml_ConferencePaper_DEL_Name(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_PublicationDate) */

int zx_hrxml_ConferencePaper_NUM_PublicationDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationDate; y; ++n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_ConferencePaper_GET_PublicationDate(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  for (y = x->PublicationDate; n>=0 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_ConferencePaper_POP_PublicationDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  y = x->PublicationDate;
  if (y)
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_PublicationDate) */

void zx_hrxml_ConferencePaper_PUSH_PublicationDate(struct zx_hrxml_ConferencePaper_s* x, struct zx_hrxml_PublicationDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationDate->gg.g;
  x->PublicationDate = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_PublicationDate) */

void zx_hrxml_ConferencePaper_REV_PublicationDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_PublicationDate_s* nxt;
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  y = x->PublicationDate;
  if (!y) return;
  x->PublicationDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_PublicationDate) */

void zx_hrxml_ConferencePaper_PUT_PublicationDate(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  y = x->PublicationDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_PublicationDate) */

void zx_hrxml_ConferencePaper_ADD_PublicationDate(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = z;
    return;
  case -1:
    y = x->PublicationDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_PublicationDate) */

void zx_hrxml_ConferencePaper_DEL_PublicationDate(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Link) */

int zx_hrxml_ConferencePaper_NUM_Link(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Link) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_Link(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Link) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_Link(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Link) */

void zx_hrxml_ConferencePaper_PUSH_Link(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Link) */

void zx_hrxml_ConferencePaper_REV_Link(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Link) */

void zx_hrxml_ConferencePaper_PUT_Link(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Link) */

void zx_hrxml_ConferencePaper_ADD_Link(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Link) */

void zx_hrxml_ConferencePaper_DEL_Link(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Abstract) */

int zx_hrxml_ConferencePaper_NUM_Abstract(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Abstract; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Abstract) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_Abstract(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Abstract; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Abstract) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_Abstract(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Abstract;
  if (y)
    x->Abstract = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Abstract) */

void zx_hrxml_ConferencePaper_PUSH_Abstract(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Abstract->g;
  x->Abstract = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Abstract) */

void zx_hrxml_ConferencePaper_REV_Abstract(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Abstract;
  if (!y) return;
  x->Abstract = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Abstract->g;
    x->Abstract = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Abstract) */

void zx_hrxml_ConferencePaper_PUT_Abstract(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Abstract;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Abstract = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Abstract) */

void zx_hrxml_ConferencePaper_ADD_Abstract(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Abstract->g;
    x->Abstract = z;
    return;
  case -1:
    y = x->Abstract;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Abstract) */

void zx_hrxml_ConferencePaper_DEL_Abstract(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Abstract = (struct zx_elem_s*)x->Abstract->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Abstract;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Copyright) */

int zx_hrxml_ConferencePaper_NUM_Copyright(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Copyright; y; ++n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_ConferencePaper_GET_Copyright(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  for (y = x->Copyright; n>=0 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_ConferencePaper_POP_Copyright(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  y = x->Copyright;
  if (y)
    x->Copyright = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Copyright) */

void zx_hrxml_ConferencePaper_PUSH_Copyright(struct zx_hrxml_ConferencePaper_s* x, struct zx_hrxml_Copyright_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Copyright->gg.g;
  x->Copyright = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Copyright) */

void zx_hrxml_ConferencePaper_REV_Copyright(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_Copyright_s* nxt;
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  y = x->Copyright;
  if (!y) return;
  x->Copyright = 0;
  while (y) {
    nxt = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
    y->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Copyright) */

void zx_hrxml_ConferencePaper_PUT_Copyright(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  y = x->Copyright;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Copyright = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Copyright) */

void zx_hrxml_ConferencePaper_ADD_Copyright(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = z;
    return;
  case -1:
    y = x->Copyright;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Copyright) */

void zx_hrxml_ConferencePaper_DEL_Copyright(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Copyright = (struct zx_hrxml_Copyright_s*)x->Copyright->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Copyright_s*)x->Copyright;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_Comments) */

int zx_hrxml_ConferencePaper_NUM_Comments(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_Comments) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_Comments(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_Comments) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_Comments(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_Comments) */

void zx_hrxml_ConferencePaper_PUSH_Comments(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_Comments) */

void zx_hrxml_ConferencePaper_REV_Comments(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_Comments) */

void zx_hrxml_ConferencePaper_PUT_Comments(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_Comments) */

void zx_hrxml_ConferencePaper_ADD_Comments(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_Comments) */

void zx_hrxml_ConferencePaper_DEL_Comments(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_EventName) */

int zx_hrxml_ConferencePaper_NUM_EventName(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EventName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_EventName) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_EventName(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EventName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_EventName) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_EventName(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EventName;
  if (y)
    x->EventName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_EventName) */

void zx_hrxml_ConferencePaper_PUSH_EventName(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EventName->g;
  x->EventName = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_EventName) */

void zx_hrxml_ConferencePaper_REV_EventName(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EventName;
  if (!y) return;
  x->EventName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EventName->g;
    x->EventName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_EventName) */

void zx_hrxml_ConferencePaper_PUT_EventName(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EventName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EventName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_EventName) */

void zx_hrxml_ConferencePaper_ADD_EventName(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EventName->g;
    x->EventName = z;
    return;
  case -1:
    y = x->EventName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_EventName) */

void zx_hrxml_ConferencePaper_DEL_EventName(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EventName = (struct zx_elem_s*)x->EventName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EventName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_ConferenceDate) */

int zx_hrxml_ConferencePaper_NUM_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_ConferenceDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ConferenceDate; y; ++n, y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_ConferenceDate) */

struct zx_hrxml_ConferenceDate_s* zx_hrxml_ConferencePaper_GET_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x) return 0;
  for (y = x->ConferenceDate; n>=0 && y; --n, y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_ConferenceDate) */

struct zx_hrxml_ConferenceDate_s* zx_hrxml_ConferencePaper_POP_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x) return 0;
  y = x->ConferenceDate;
  if (y)
    x->ConferenceDate = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_ConferenceDate) */

void zx_hrxml_ConferencePaper_PUSH_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x, struct zx_hrxml_ConferenceDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ConferenceDate->gg.g;
  x->ConferenceDate = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_ConferenceDate) */

void zx_hrxml_ConferencePaper_REV_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_hrxml_ConferenceDate_s* nxt;
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x) return;
  y = x->ConferenceDate;
  if (!y) return;
  x->ConferenceDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n;
    y->gg.g.n = &x->ConferenceDate->gg.g;
    x->ConferenceDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_ConferenceDate) */

void zx_hrxml_ConferencePaper_PUT_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_ConferenceDate_s* z)
{
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x || !z) return;
  y = x->ConferenceDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ConferenceDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_ConferenceDate) */

void zx_hrxml_ConferencePaper_ADD_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_hrxml_ConferenceDate_s* z)
{
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ConferenceDate->gg.g;
    x->ConferenceDate = z;
    return;
  case -1:
    y = x->ConferenceDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ConferenceDate; n > 1 && y; --n, y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_ConferenceDate) */

void zx_hrxml_ConferencePaper_DEL_ConferenceDate(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_hrxml_ConferenceDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ConferenceDate = (struct zx_hrxml_ConferenceDate_s*)x->ConferenceDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ConferenceDate_s*)x->ConferenceDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ConferenceDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ConferenceDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ConferencePaper_NUM_ConferenceLocation) */

int zx_hrxml_ConferencePaper_NUM_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ConferenceLocation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ConferencePaper_GET_ConferenceLocation) */

struct zx_elem_s* zx_hrxml_ConferencePaper_GET_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ConferenceLocation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_POP_ConferenceLocation) */

struct zx_elem_s* zx_hrxml_ConferencePaper_POP_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ConferenceLocation;
  if (y)
    x->ConferenceLocation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ConferencePaper_PUSH_ConferenceLocation) */

void zx_hrxml_ConferencePaper_PUSH_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ConferenceLocation->g;
  x->ConferenceLocation = z;
}

/* FUNC(zx_hrxml_ConferencePaper_REV_ConferenceLocation) */

void zx_hrxml_ConferencePaper_REV_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ConferenceLocation;
  if (!y) return;
  x->ConferenceLocation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ConferenceLocation->g;
    x->ConferenceLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_PUT_ConferenceLocation) */

void zx_hrxml_ConferencePaper_PUT_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ConferenceLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ConferenceLocation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ConferencePaper_ADD_ConferenceLocation) */

void zx_hrxml_ConferencePaper_ADD_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ConferenceLocation->g;
    x->ConferenceLocation = z;
    return;
  case -1:
    y = x->ConferenceLocation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ConferenceLocation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ConferencePaper_DEL_ConferenceLocation) */

void zx_hrxml_ConferencePaper_DEL_ConferenceLocation(struct zx_hrxml_ConferencePaper_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ConferenceLocation = (struct zx_elem_s*)x->ConferenceLocation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ConferenceLocation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ConferenceLocation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Considerations_NUM_General) */

int zx_hrxml_Considerations_NUM_General(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->General; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Considerations_GET_General) */

struct zx_elem_s* zx_hrxml_Considerations_GET_General(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->General; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Considerations_POP_General) */

struct zx_elem_s* zx_hrxml_Considerations_POP_General(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->General;
  if (y)
    x->General = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Considerations_PUSH_General) */

void zx_hrxml_Considerations_PUSH_General(struct zx_hrxml_Considerations_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->General->g;
  x->General = z;
}

/* FUNC(zx_hrxml_Considerations_REV_General) */

void zx_hrxml_Considerations_REV_General(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->General;
  if (!y) return;
  x->General = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->General->g;
    x->General = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Considerations_PUT_General) */

void zx_hrxml_Considerations_PUT_General(struct zx_hrxml_Considerations_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->General;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->General = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Considerations_ADD_General) */

void zx_hrxml_Considerations_ADD_General(struct zx_hrxml_Considerations_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->General->g;
    x->General = z;
    return;
  case -1:
    y = x->General;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->General; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Considerations_DEL_General) */

void zx_hrxml_Considerations_DEL_General(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->General = (struct zx_elem_s*)x->General->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->General;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->General; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Considerations_NUM_Physical) */

int zx_hrxml_Considerations_NUM_Physical(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Physical; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Considerations_GET_Physical) */

struct zx_elem_s* zx_hrxml_Considerations_GET_Physical(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Physical; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Considerations_POP_Physical) */

struct zx_elem_s* zx_hrxml_Considerations_POP_Physical(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Physical;
  if (y)
    x->Physical = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Considerations_PUSH_Physical) */

void zx_hrxml_Considerations_PUSH_Physical(struct zx_hrxml_Considerations_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Physical->g;
  x->Physical = z;
}

/* FUNC(zx_hrxml_Considerations_REV_Physical) */

void zx_hrxml_Considerations_REV_Physical(struct zx_hrxml_Considerations_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Physical;
  if (!y) return;
  x->Physical = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Physical->g;
    x->Physical = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Considerations_PUT_Physical) */

void zx_hrxml_Considerations_PUT_Physical(struct zx_hrxml_Considerations_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Physical;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Physical = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Considerations_ADD_Physical) */

void zx_hrxml_Considerations_ADD_Physical(struct zx_hrxml_Considerations_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Physical->g;
    x->Physical = z;
    return;
  case -1:
    y = x->Physical;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Physical; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Considerations_DEL_Physical) */

void zx_hrxml_Considerations_DEL_Physical(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Physical = (struct zx_elem_s*)x->Physical->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Physical;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Physical; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Considerations_NUM_SafetyEquipment) */

int zx_hrxml_Considerations_NUM_SafetyEquipment(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SafetyEquipment; y; ++n, y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Considerations_GET_SafetyEquipment) */

struct zx_hrxml_SafetyEquipment_s* zx_hrxml_Considerations_GET_SafetyEquipment(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x) return 0;
  for (y = x->SafetyEquipment; n>=0 && y; --n, y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Considerations_POP_SafetyEquipment) */

struct zx_hrxml_SafetyEquipment_s* zx_hrxml_Considerations_POP_SafetyEquipment(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x) return 0;
  y = x->SafetyEquipment;
  if (y)
    x->SafetyEquipment = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Considerations_PUSH_SafetyEquipment) */

void zx_hrxml_Considerations_PUSH_SafetyEquipment(struct zx_hrxml_Considerations_s* x, struct zx_hrxml_SafetyEquipment_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SafetyEquipment->gg.g;
  x->SafetyEquipment = z;
}

/* FUNC(zx_hrxml_Considerations_REV_SafetyEquipment) */

void zx_hrxml_Considerations_REV_SafetyEquipment(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_SafetyEquipment_s* nxt;
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x) return;
  y = x->SafetyEquipment;
  if (!y) return;
  x->SafetyEquipment = 0;
  while (y) {
    nxt = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n;
    y->gg.g.n = &x->SafetyEquipment->gg.g;
    x->SafetyEquipment = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Considerations_PUT_SafetyEquipment) */

void zx_hrxml_Considerations_PUT_SafetyEquipment(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_SafetyEquipment_s* z)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x || !z) return;
  y = x->SafetyEquipment;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SafetyEquipment = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Considerations_ADD_SafetyEquipment) */

void zx_hrxml_Considerations_ADD_SafetyEquipment(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_SafetyEquipment_s* z)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SafetyEquipment->gg.g;
    x->SafetyEquipment = z;
    return;
  case -1:
    y = x->SafetyEquipment;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SafetyEquipment; n > 1 && y; --n, y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Considerations_DEL_SafetyEquipment) */

void zx_hrxml_Considerations_DEL_SafetyEquipment(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_SafetyEquipment_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SafetyEquipment = (struct zx_hrxml_SafetyEquipment_s*)x->SafetyEquipment->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SafetyEquipment_s*)x->SafetyEquipment;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SafetyEquipment; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SafetyEquipment_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Considerations_NUM_DressCode) */

int zx_hrxml_Considerations_NUM_DressCode(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DressCode; y; ++n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Considerations_GET_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_Considerations_GET_DressCode(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  for (y = x->DressCode; n>=0 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Considerations_POP_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_Considerations_POP_DressCode(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  y = x->DressCode;
  if (y)
    x->DressCode = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Considerations_PUSH_DressCode) */

void zx_hrxml_Considerations_PUSH_DressCode(struct zx_hrxml_Considerations_s* x, struct zx_hrxml_DressCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DressCode->gg.g;
  x->DressCode = z;
}

/* FUNC(zx_hrxml_Considerations_REV_DressCode) */

void zx_hrxml_Considerations_REV_DressCode(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_DressCode_s* nxt;
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  y = x->DressCode;
  if (!y) return;
  x->DressCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
    y->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Considerations_PUT_DressCode) */

void zx_hrxml_Considerations_PUT_DressCode(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  y = x->DressCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DressCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Considerations_ADD_DressCode) */

void zx_hrxml_Considerations_ADD_DressCode(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = z;
    return;
  case -1:
    y = x->DressCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Considerations_DEL_DressCode) */

void zx_hrxml_Considerations_DEL_DressCode(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DressCode = (struct zx_hrxml_DressCode_s*)x->DressCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DressCode_s*)x->DressCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Considerations_NUM_UserArea) */

int zx_hrxml_Considerations_NUM_UserArea(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Considerations_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Considerations_GET_UserArea(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Considerations_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Considerations_POP_UserArea(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Considerations_PUSH_UserArea) */

void zx_hrxml_Considerations_PUSH_UserArea(struct zx_hrxml_Considerations_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_Considerations_REV_UserArea) */

void zx_hrxml_Considerations_REV_UserArea(struct zx_hrxml_Considerations_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Considerations_PUT_UserArea) */

void zx_hrxml_Considerations_PUT_UserArea(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Considerations_ADD_UserArea) */

void zx_hrxml_Considerations_ADD_UserArea(struct zx_hrxml_Considerations_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Considerations_DEL_UserArea) */

void zx_hrxml_Considerations_DEL_UserArea(struct zx_hrxml_Considerations_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Considerations_GET_lang) */
struct zx_str* zx_hrxml_Considerations_GET_lang(struct zx_hrxml_Considerations_s* x) { return x->lang; }
/* FUNC(zx_hrxml_Considerations_PUT_lang) */
void zx_hrxml_Considerations_PUT_lang(struct zx_hrxml_Considerations_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactId_NUM_IdValue) */

int zx_hrxml_ContactId_NUM_IdValue(struct zx_hrxml_ContactId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ContactId_GET_IdValue(struct zx_hrxml_ContactId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ContactId_POP_IdValue(struct zx_hrxml_ContactId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactId_PUSH_IdValue) */

void zx_hrxml_ContactId_PUSH_IdValue(struct zx_hrxml_ContactId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_ContactId_REV_IdValue) */

void zx_hrxml_ContactId_REV_IdValue(struct zx_hrxml_ContactId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactId_PUT_IdValue) */

void zx_hrxml_ContactId_PUT_IdValue(struct zx_hrxml_ContactId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactId_ADD_IdValue) */

void zx_hrxml_ContactId_ADD_IdValue(struct zx_hrxml_ContactId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactId_DEL_IdValue) */

void zx_hrxml_ContactId_DEL_IdValue(struct zx_hrxml_ContactId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ContactId_GET_idOwner) */
struct zx_str* zx_hrxml_ContactId_GET_idOwner(struct zx_hrxml_ContactId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_ContactId_PUT_idOwner) */
void zx_hrxml_ContactId_PUT_idOwner(struct zx_hrxml_ContactId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_ContactId_GET_validFrom) */
struct zx_str* zx_hrxml_ContactId_GET_validFrom(struct zx_hrxml_ContactId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_ContactId_PUT_validFrom) */
void zx_hrxml_ContactId_PUT_validFrom(struct zx_hrxml_ContactId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_ContactId_GET_validTo) */
struct zx_str* zx_hrxml_ContactId_GET_validTo(struct zx_hrxml_ContactId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_ContactId_PUT_validTo) */
void zx_hrxml_ContactId_PUT_validTo(struct zx_hrxml_ContactId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactInfo_NUM_PersonName) */

int zx_hrxml_ContactInfo_NUM_PersonName(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactInfo_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_ContactInfo_GET_PersonName(struct zx_hrxml_ContactInfo_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactInfo_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_ContactInfo_POP_PersonName(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactInfo_PUSH_PersonName) */

void zx_hrxml_ContactInfo_PUSH_PersonName(struct zx_hrxml_ContactInfo_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_ContactInfo_REV_PersonName) */

void zx_hrxml_ContactInfo_REV_PersonName(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactInfo_PUT_PersonName) */

void zx_hrxml_ContactInfo_PUT_PersonName(struct zx_hrxml_ContactInfo_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactInfo_ADD_PersonName) */

void zx_hrxml_ContactInfo_ADD_PersonName(struct zx_hrxml_ContactInfo_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactInfo_DEL_PersonName) */

void zx_hrxml_ContactInfo_DEL_PersonName(struct zx_hrxml_ContactInfo_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactInfo_NUM_ContactMethod) */

int zx_hrxml_ContactInfo_NUM_ContactMethod(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactInfo_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_ContactInfo_GET_ContactMethod(struct zx_hrxml_ContactInfo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactInfo_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_ContactInfo_POP_ContactMethod(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactInfo_PUSH_ContactMethod) */

void zx_hrxml_ContactInfo_PUSH_ContactMethod(struct zx_hrxml_ContactInfo_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_ContactInfo_REV_ContactMethod) */

void zx_hrxml_ContactInfo_REV_ContactMethod(struct zx_hrxml_ContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactInfo_PUT_ContactMethod) */

void zx_hrxml_ContactInfo_PUT_ContactMethod(struct zx_hrxml_ContactInfo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactInfo_ADD_ContactMethod) */

void zx_hrxml_ContactInfo_ADD_ContactMethod(struct zx_hrxml_ContactInfo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactInfo_DEL_ContactMethod) */

void zx_hrxml_ContactInfo_DEL_ContactMethod(struct zx_hrxml_ContactInfo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Use) */

int zx_hrxml_ContactMethod_NUM_Use(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Use; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Use) */

struct zx_elem_s* zx_hrxml_ContactMethod_GET_Use(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Use; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Use) */

struct zx_elem_s* zx_hrxml_ContactMethod_POP_Use(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Use;
  if (y)
    x->Use = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Use) */

void zx_hrxml_ContactMethod_PUSH_Use(struct zx_hrxml_ContactMethod_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Use->g;
  x->Use = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Use) */

void zx_hrxml_ContactMethod_REV_Use(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Use;
  if (!y) return;
  x->Use = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Use->g;
    x->Use = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Use) */

void zx_hrxml_ContactMethod_PUT_Use(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Use;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Use = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Use) */

void zx_hrxml_ContactMethod_ADD_Use(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Use->g;
    x->Use = z;
    return;
  case -1:
    y = x->Use;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Use; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Use) */

void zx_hrxml_ContactMethod_DEL_Use(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Use = (struct zx_elem_s*)x->Use->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Use;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Use; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Location) */

int zx_hrxml_ContactMethod_NUM_Location(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Location; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Location) */

struct zx_elem_s* zx_hrxml_ContactMethod_GET_Location(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Location; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Location) */

struct zx_elem_s* zx_hrxml_ContactMethod_POP_Location(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Location;
  if (y)
    x->Location = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Location) */

void zx_hrxml_ContactMethod_PUSH_Location(struct zx_hrxml_ContactMethod_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Location->g;
  x->Location = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Location) */

void zx_hrxml_ContactMethod_REV_Location(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Location;
  if (!y) return;
  x->Location = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Location->g;
    x->Location = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Location) */

void zx_hrxml_ContactMethod_PUT_Location(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Location;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Location = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Location) */

void zx_hrxml_ContactMethod_ADD_Location(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Location->g;
    x->Location = z;
    return;
  case -1:
    y = x->Location;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Location; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Location) */

void zx_hrxml_ContactMethod_DEL_Location(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Location = (struct zx_elem_s*)x->Location->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Location;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Location; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_WhenAvailable) */

int zx_hrxml_ContactMethod_NUM_WhenAvailable(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WhenAvailable; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_WhenAvailable) */

struct zx_elem_s* zx_hrxml_ContactMethod_GET_WhenAvailable(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->WhenAvailable; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_WhenAvailable) */

struct zx_elem_s* zx_hrxml_ContactMethod_POP_WhenAvailable(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->WhenAvailable;
  if (y)
    x->WhenAvailable = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_WhenAvailable) */

void zx_hrxml_ContactMethod_PUSH_WhenAvailable(struct zx_hrxml_ContactMethod_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->WhenAvailable->g;
  x->WhenAvailable = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_WhenAvailable) */

void zx_hrxml_ContactMethod_REV_WhenAvailable(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->WhenAvailable;
  if (!y) return;
  x->WhenAvailable = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->WhenAvailable->g;
    x->WhenAvailable = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_WhenAvailable) */

void zx_hrxml_ContactMethod_PUT_WhenAvailable(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->WhenAvailable;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->WhenAvailable = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_WhenAvailable) */

void zx_hrxml_ContactMethod_ADD_WhenAvailable(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->WhenAvailable->g;
    x->WhenAvailable = z;
    return;
  case -1:
    y = x->WhenAvailable;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WhenAvailable; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_WhenAvailable) */

void zx_hrxml_ContactMethod_DEL_WhenAvailable(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WhenAvailable = (struct zx_elem_s*)x->WhenAvailable->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->WhenAvailable;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WhenAvailable; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Telephone) */

int zx_hrxml_ContactMethod_NUM_Telephone(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Telephone_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Telephone; y; ++n, y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Telephone) */

struct zx_hrxml_Telephone_s* zx_hrxml_ContactMethod_GET_Telephone(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Telephone_s* y;
  if (!x) return 0;
  for (y = x->Telephone; n>=0 && y; --n, y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Telephone) */

struct zx_hrxml_Telephone_s* zx_hrxml_ContactMethod_POP_Telephone(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Telephone_s* y;
  if (!x) return 0;
  y = x->Telephone;
  if (y)
    x->Telephone = (struct zx_hrxml_Telephone_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Telephone) */

void zx_hrxml_ContactMethod_PUSH_Telephone(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_Telephone_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Telephone->gg.g;
  x->Telephone = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Telephone) */

void zx_hrxml_ContactMethod_REV_Telephone(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Telephone_s* nxt;
  struct zx_hrxml_Telephone_s* y;
  if (!x) return;
  y = x->Telephone;
  if (!y) return;
  x->Telephone = 0;
  while (y) {
    nxt = (struct zx_hrxml_Telephone_s*)y->gg.g.n;
    y->gg.g.n = &x->Telephone->gg.g;
    x->Telephone = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Telephone) */

void zx_hrxml_ContactMethod_PUT_Telephone(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Telephone_s* z)
{
  struct zx_hrxml_Telephone_s* y;
  if (!x || !z) return;
  y = x->Telephone;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Telephone = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Telephone) */

void zx_hrxml_ContactMethod_ADD_Telephone(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Telephone_s* z)
{
  struct zx_hrxml_Telephone_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Telephone->gg.g;
    x->Telephone = z;
    return;
  case -1:
    y = x->Telephone;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Telephone; n > 1 && y; --n, y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Telephone) */

void zx_hrxml_ContactMethod_DEL_Telephone(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Telephone_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Telephone = (struct zx_hrxml_Telephone_s*)x->Telephone->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Telephone_s*)x->Telephone;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Telephone; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Telephone_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Mobile) */

int zx_hrxml_ContactMethod_NUM_Mobile(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Mobile_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Mobile; y; ++n, y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Mobile) */

struct zx_hrxml_Mobile_s* zx_hrxml_ContactMethod_GET_Mobile(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Mobile_s* y;
  if (!x) return 0;
  for (y = x->Mobile; n>=0 && y; --n, y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Mobile) */

struct zx_hrxml_Mobile_s* zx_hrxml_ContactMethod_POP_Mobile(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Mobile_s* y;
  if (!x) return 0;
  y = x->Mobile;
  if (y)
    x->Mobile = (struct zx_hrxml_Mobile_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Mobile) */

void zx_hrxml_ContactMethod_PUSH_Mobile(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_Mobile_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Mobile->gg.g;
  x->Mobile = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Mobile) */

void zx_hrxml_ContactMethod_REV_Mobile(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Mobile_s* nxt;
  struct zx_hrxml_Mobile_s* y;
  if (!x) return;
  y = x->Mobile;
  if (!y) return;
  x->Mobile = 0;
  while (y) {
    nxt = (struct zx_hrxml_Mobile_s*)y->gg.g.n;
    y->gg.g.n = &x->Mobile->gg.g;
    x->Mobile = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Mobile) */

void zx_hrxml_ContactMethod_PUT_Mobile(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Mobile_s* z)
{
  struct zx_hrxml_Mobile_s* y;
  if (!x || !z) return;
  y = x->Mobile;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Mobile = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Mobile) */

void zx_hrxml_ContactMethod_ADD_Mobile(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Mobile_s* z)
{
  struct zx_hrxml_Mobile_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Mobile->gg.g;
    x->Mobile = z;
    return;
  case -1:
    y = x->Mobile;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Mobile; n > 1 && y; --n, y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Mobile) */

void zx_hrxml_ContactMethod_DEL_Mobile(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Mobile_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Mobile = (struct zx_hrxml_Mobile_s*)x->Mobile->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Mobile_s*)x->Mobile;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Mobile; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Mobile_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Fax) */

int zx_hrxml_ContactMethod_NUM_Fax(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Fax_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Fax; y; ++n, y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Fax) */

struct zx_hrxml_Fax_s* zx_hrxml_ContactMethod_GET_Fax(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Fax_s* y;
  if (!x) return 0;
  for (y = x->Fax; n>=0 && y; --n, y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Fax) */

struct zx_hrxml_Fax_s* zx_hrxml_ContactMethod_POP_Fax(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Fax_s* y;
  if (!x) return 0;
  y = x->Fax;
  if (y)
    x->Fax = (struct zx_hrxml_Fax_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Fax) */

void zx_hrxml_ContactMethod_PUSH_Fax(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_Fax_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Fax->gg.g;
  x->Fax = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Fax) */

void zx_hrxml_ContactMethod_REV_Fax(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Fax_s* nxt;
  struct zx_hrxml_Fax_s* y;
  if (!x) return;
  y = x->Fax;
  if (!y) return;
  x->Fax = 0;
  while (y) {
    nxt = (struct zx_hrxml_Fax_s*)y->gg.g.n;
    y->gg.g.n = &x->Fax->gg.g;
    x->Fax = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Fax) */

void zx_hrxml_ContactMethod_PUT_Fax(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Fax_s* z)
{
  struct zx_hrxml_Fax_s* y;
  if (!x || !z) return;
  y = x->Fax;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Fax = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Fax) */

void zx_hrxml_ContactMethod_ADD_Fax(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Fax_s* z)
{
  struct zx_hrxml_Fax_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Fax->gg.g;
    x->Fax = z;
    return;
  case -1:
    y = x->Fax;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Fax; n > 1 && y; --n, y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Fax) */

void zx_hrxml_ContactMethod_DEL_Fax(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Fax_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Fax = (struct zx_hrxml_Fax_s*)x->Fax->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Fax_s*)x->Fax;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Fax; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Fax_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_Pager) */

int zx_hrxml_ContactMethod_NUM_Pager(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Pager_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Pager; y; ++n, y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_Pager) */

struct zx_hrxml_Pager_s* zx_hrxml_ContactMethod_GET_Pager(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Pager_s* y;
  if (!x) return 0;
  for (y = x->Pager; n>=0 && y; --n, y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_Pager) */

struct zx_hrxml_Pager_s* zx_hrxml_ContactMethod_POP_Pager(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Pager_s* y;
  if (!x) return 0;
  y = x->Pager;
  if (y)
    x->Pager = (struct zx_hrxml_Pager_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_Pager) */

void zx_hrxml_ContactMethod_PUSH_Pager(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_Pager_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Pager->gg.g;
  x->Pager = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_Pager) */

void zx_hrxml_ContactMethod_REV_Pager(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_Pager_s* nxt;
  struct zx_hrxml_Pager_s* y;
  if (!x) return;
  y = x->Pager;
  if (!y) return;
  x->Pager = 0;
  while (y) {
    nxt = (struct zx_hrxml_Pager_s*)y->gg.g.n;
    y->gg.g.n = &x->Pager->gg.g;
    x->Pager = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_Pager) */

void zx_hrxml_ContactMethod_PUT_Pager(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Pager_s* z)
{
  struct zx_hrxml_Pager_s* y;
  if (!x || !z) return;
  y = x->Pager;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Pager = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_Pager) */

void zx_hrxml_ContactMethod_ADD_Pager(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_Pager_s* z)
{
  struct zx_hrxml_Pager_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Pager->gg.g;
    x->Pager = z;
    return;
  case -1:
    y = x->Pager;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Pager; n > 1 && y; --n, y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_Pager) */

void zx_hrxml_ContactMethod_DEL_Pager(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_Pager_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Pager = (struct zx_hrxml_Pager_s*)x->Pager->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Pager_s*)x->Pager;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Pager; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Pager_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_TTYTDD) */

int zx_hrxml_ContactMethod_NUM_TTYTDD(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_TTYTDD_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TTYTDD; y; ++n, y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_TTYTDD) */

struct zx_hrxml_TTYTDD_s* zx_hrxml_ContactMethod_GET_TTYTDD(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_TTYTDD_s* y;
  if (!x) return 0;
  for (y = x->TTYTDD; n>=0 && y; --n, y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_TTYTDD) */

struct zx_hrxml_TTYTDD_s* zx_hrxml_ContactMethod_POP_TTYTDD(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_TTYTDD_s* y;
  if (!x) return 0;
  y = x->TTYTDD;
  if (y)
    x->TTYTDD = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_TTYTDD) */

void zx_hrxml_ContactMethod_PUSH_TTYTDD(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_TTYTDD_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TTYTDD->gg.g;
  x->TTYTDD = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_TTYTDD) */

void zx_hrxml_ContactMethod_REV_TTYTDD(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_TTYTDD_s* nxt;
  struct zx_hrxml_TTYTDD_s* y;
  if (!x) return;
  y = x->TTYTDD;
  if (!y) return;
  x->TTYTDD = 0;
  while (y) {
    nxt = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n;
    y->gg.g.n = &x->TTYTDD->gg.g;
    x->TTYTDD = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_TTYTDD) */

void zx_hrxml_ContactMethod_PUT_TTYTDD(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_TTYTDD_s* z)
{
  struct zx_hrxml_TTYTDD_s* y;
  if (!x || !z) return;
  y = x->TTYTDD;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TTYTDD = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_TTYTDD) */

void zx_hrxml_ContactMethod_ADD_TTYTDD(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_TTYTDD_s* z)
{
  struct zx_hrxml_TTYTDD_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TTYTDD->gg.g;
    x->TTYTDD = z;
    return;
  case -1:
    y = x->TTYTDD;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TTYTDD; n > 1 && y; --n, y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_TTYTDD) */

void zx_hrxml_ContactMethod_DEL_TTYTDD(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_TTYTDD_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TTYTDD = (struct zx_hrxml_TTYTDD_s*)x->TTYTDD->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TTYTDD_s*)x->TTYTDD;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TTYTDD; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TTYTDD_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_InternetEmailAddress) */

int zx_hrxml_ContactMethod_NUM_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InternetEmailAddress; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_InternetEmailAddress) */

struct zx_elem_s* zx_hrxml_ContactMethod_GET_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->InternetEmailAddress; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_InternetEmailAddress) */

struct zx_elem_s* zx_hrxml_ContactMethod_POP_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->InternetEmailAddress;
  if (y)
    x->InternetEmailAddress = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_InternetEmailAddress) */

void zx_hrxml_ContactMethod_PUSH_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->InternetEmailAddress->g;
  x->InternetEmailAddress = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_InternetEmailAddress) */

void zx_hrxml_ContactMethod_REV_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->InternetEmailAddress;
  if (!y) return;
  x->InternetEmailAddress = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->InternetEmailAddress->g;
    x->InternetEmailAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_InternetEmailAddress) */

void zx_hrxml_ContactMethod_PUT_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->InternetEmailAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->InternetEmailAddress = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_InternetEmailAddress) */

void zx_hrxml_ContactMethod_ADD_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->InternetEmailAddress->g;
    x->InternetEmailAddress = z;
    return;
  case -1:
    y = x->InternetEmailAddress;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InternetEmailAddress; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_InternetEmailAddress) */

void zx_hrxml_ContactMethod_DEL_InternetEmailAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InternetEmailAddress = (struct zx_elem_s*)x->InternetEmailAddress->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->InternetEmailAddress;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InternetEmailAddress; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_InternetWebAddress) */

int zx_hrxml_ContactMethod_NUM_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InternetWebAddress; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_InternetWebAddress) */

struct zx_elem_s* zx_hrxml_ContactMethod_GET_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->InternetWebAddress; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_InternetWebAddress) */

struct zx_elem_s* zx_hrxml_ContactMethod_POP_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->InternetWebAddress;
  if (y)
    x->InternetWebAddress = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_InternetWebAddress) */

void zx_hrxml_ContactMethod_PUSH_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->InternetWebAddress->g;
  x->InternetWebAddress = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_InternetWebAddress) */

void zx_hrxml_ContactMethod_REV_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->InternetWebAddress;
  if (!y) return;
  x->InternetWebAddress = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->InternetWebAddress->g;
    x->InternetWebAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_InternetWebAddress) */

void zx_hrxml_ContactMethod_PUT_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->InternetWebAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->InternetWebAddress = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_InternetWebAddress) */

void zx_hrxml_ContactMethod_ADD_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->InternetWebAddress->g;
    x->InternetWebAddress = z;
    return;
  case -1:
    y = x->InternetWebAddress;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InternetWebAddress; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_InternetWebAddress) */

void zx_hrxml_ContactMethod_DEL_InternetWebAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InternetWebAddress = (struct zx_elem_s*)x->InternetWebAddress->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->InternetWebAddress;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InternetWebAddress; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactMethod_NUM_PostalAddress) */

int zx_hrxml_ContactMethod_NUM_PostalAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalAddress; y; ++n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactMethod_GET_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_ContactMethod_GET_PostalAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  for (y = x->PostalAddress; n>=0 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_POP_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_ContactMethod_POP_PostalAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  y = x->PostalAddress;
  if (y)
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactMethod_PUSH_PostalAddress) */

void zx_hrxml_ContactMethod_PUSH_PostalAddress(struct zx_hrxml_ContactMethod_s* x, struct zx_hrxml_PostalAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PostalAddress->gg.g;
  x->PostalAddress = z;
}

/* FUNC(zx_hrxml_ContactMethod_REV_PostalAddress) */

void zx_hrxml_ContactMethod_REV_PostalAddress(struct zx_hrxml_ContactMethod_s* x)
{
  struct zx_hrxml_PostalAddress_s* nxt;
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  y = x->PostalAddress;
  if (!y) return;
  x->PostalAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactMethod_PUT_PostalAddress) */

void zx_hrxml_ContactMethod_PUT_PostalAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  y = x->PostalAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PostalAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactMethod_ADD_PostalAddress) */

void zx_hrxml_ContactMethod_ADD_PostalAddress(struct zx_hrxml_ContactMethod_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = z;
    return;
  case -1:
    y = x->PostalAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactMethod_DEL_PostalAddress) */

void zx_hrxml_ContactMethod_DEL_PostalAddress(struct zx_hrxml_ContactMethod_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_FormattedName) */

int zx_hrxml_ContactName_NUM_FormattedName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_FormattedName) */

struct zx_elem_s* zx_hrxml_ContactName_GET_FormattedName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_FormattedName) */

struct zx_elem_s* zx_hrxml_ContactName_POP_FormattedName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedName;
  if (y)
    x->FormattedName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_FormattedName) */

void zx_hrxml_ContactName_PUSH_FormattedName(struct zx_hrxml_ContactName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedName->g;
  x->FormattedName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_FormattedName) */

void zx_hrxml_ContactName_REV_FormattedName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedName;
  if (!y) return;
  x->FormattedName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedName->g;
    x->FormattedName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_FormattedName) */

void zx_hrxml_ContactName_PUT_FormattedName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_FormattedName) */

void zx_hrxml_ContactName_ADD_FormattedName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedName->g;
    x->FormattedName = z;
    return;
  case -1:
    y = x->FormattedName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactName_DEL_FormattedName) */

void zx_hrxml_ContactName_DEL_FormattedName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedName = (struct zx_elem_s*)x->FormattedName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_LegalName) */

int zx_hrxml_ContactName_NUM_LegalName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_LegalName) */

struct zx_elem_s* zx_hrxml_ContactName_GET_LegalName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->LegalName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_LegalName) */

struct zx_elem_s* zx_hrxml_ContactName_POP_LegalName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->LegalName;
  if (y)
    x->LegalName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_LegalName) */

void zx_hrxml_ContactName_PUSH_LegalName(struct zx_hrxml_ContactName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->LegalName->g;
  x->LegalName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_LegalName) */

void zx_hrxml_ContactName_REV_LegalName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->LegalName;
  if (!y) return;
  x->LegalName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->LegalName->g;
    x->LegalName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_LegalName) */

void zx_hrxml_ContactName_PUT_LegalName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->LegalName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->LegalName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_LegalName) */

void zx_hrxml_ContactName_ADD_LegalName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->LegalName->g;
    x->LegalName = z;
    return;
  case -1:
    y = x->LegalName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactName_DEL_LegalName) */

void zx_hrxml_ContactName_DEL_LegalName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalName = (struct zx_elem_s*)x->LegalName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->LegalName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_GivenName) */

int zx_hrxml_ContactName_NUM_GivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->GivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_GivenName) */

struct zx_elem_s* zx_hrxml_ContactName_GET_GivenName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->GivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_GivenName) */

struct zx_elem_s* zx_hrxml_ContactName_POP_GivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->GivenName;
  if (y)
    x->GivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_GivenName) */

void zx_hrxml_ContactName_PUSH_GivenName(struct zx_hrxml_ContactName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->GivenName->g;
  x->GivenName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_GivenName) */

void zx_hrxml_ContactName_REV_GivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->GivenName;
  if (!y) return;
  x->GivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->GivenName->g;
    x->GivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_GivenName) */

void zx_hrxml_ContactName_PUT_GivenName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->GivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->GivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_GivenName) */

void zx_hrxml_ContactName_ADD_GivenName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->GivenName->g;
    x->GivenName = z;
    return;
  case -1:
    y = x->GivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactName_DEL_GivenName) */

void zx_hrxml_ContactName_DEL_GivenName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->GivenName = (struct zx_elem_s*)x->GivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->GivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_PreferredGivenName) */

int zx_hrxml_ContactName_NUM_PreferredGivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredGivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_ContactName_GET_PreferredGivenName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PreferredGivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_ContactName_POP_PreferredGivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PreferredGivenName;
  if (y)
    x->PreferredGivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_PreferredGivenName) */

void zx_hrxml_ContactName_PUSH_PreferredGivenName(struct zx_hrxml_ContactName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PreferredGivenName->g;
  x->PreferredGivenName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_PreferredGivenName) */

void zx_hrxml_ContactName_REV_PreferredGivenName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PreferredGivenName;
  if (!y) return;
  x->PreferredGivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_PreferredGivenName) */

void zx_hrxml_ContactName_PUT_PreferredGivenName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PreferredGivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PreferredGivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_PreferredGivenName) */

void zx_hrxml_ContactName_ADD_PreferredGivenName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = z;
    return;
  case -1:
    y = x->PreferredGivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactName_DEL_PreferredGivenName) */

void zx_hrxml_ContactName_DEL_PreferredGivenName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredGivenName = (struct zx_elem_s*)x->PreferredGivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PreferredGivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_MiddleName) */

int zx_hrxml_ContactName_NUM_MiddleName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MiddleName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_MiddleName) */

struct zx_elem_s* zx_hrxml_ContactName_GET_MiddleName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MiddleName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_MiddleName) */

struct zx_elem_s* zx_hrxml_ContactName_POP_MiddleName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MiddleName;
  if (y)
    x->MiddleName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_MiddleName) */

void zx_hrxml_ContactName_PUSH_MiddleName(struct zx_hrxml_ContactName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MiddleName->g;
  x->MiddleName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_MiddleName) */

void zx_hrxml_ContactName_REV_MiddleName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MiddleName;
  if (!y) return;
  x->MiddleName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MiddleName->g;
    x->MiddleName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_MiddleName) */

void zx_hrxml_ContactName_PUT_MiddleName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MiddleName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MiddleName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_MiddleName) */

void zx_hrxml_ContactName_ADD_MiddleName(struct zx_hrxml_ContactName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MiddleName->g;
    x->MiddleName = z;
    return;
  case -1:
    y = x->MiddleName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ContactName_DEL_MiddleName) */

void zx_hrxml_ContactName_DEL_MiddleName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MiddleName = (struct zx_elem_s*)x->MiddleName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MiddleName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_FamilyName) */

int zx_hrxml_ContactName_NUM_FamilyName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FamilyName; y; ++n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_ContactName_GET_FamilyName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  for (y = x->FamilyName; n>=0 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_ContactName_POP_FamilyName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  y = x->FamilyName;
  if (y)
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_FamilyName) */

void zx_hrxml_ContactName_PUSH_FamilyName(struct zx_hrxml_ContactName_s* x, struct zx_hrxml_FamilyName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->FamilyName->gg.g;
  x->FamilyName = z;
}

/* FUNC(zx_hrxml_ContactName_REV_FamilyName) */

void zx_hrxml_ContactName_REV_FamilyName(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_FamilyName_s* nxt;
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  y = x->FamilyName;
  if (!y) return;
  x->FamilyName = 0;
  while (y) {
    nxt = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
    y->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_FamilyName) */

void zx_hrxml_ContactName_PUT_FamilyName(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  y = x->FamilyName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->FamilyName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_FamilyName) */

void zx_hrxml_ContactName_ADD_FamilyName(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = z;
    return;
  case -1:
    y = x->FamilyName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactName_DEL_FamilyName) */

void zx_hrxml_ContactName_DEL_FamilyName(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)x->FamilyName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_FamilyName_s*)x->FamilyName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_Affix) */

int zx_hrxml_ContactName_NUM_Affix(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_Affix_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Affix; y; ++n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_ContactName_GET_Affix(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  for (y = x->Affix; n>=0 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_ContactName_POP_Affix(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  y = x->Affix;
  if (y)
    x->Affix = (struct zx_hrxml_Affix_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_Affix) */

void zx_hrxml_ContactName_PUSH_Affix(struct zx_hrxml_ContactName_s* x, struct zx_hrxml_Affix_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Affix->gg.g;
  x->Affix = z;
}

/* FUNC(zx_hrxml_ContactName_REV_Affix) */

void zx_hrxml_ContactName_REV_Affix(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_Affix_s* nxt;
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  y = x->Affix;
  if (!y) return;
  x->Affix = 0;
  while (y) {
    nxt = (struct zx_hrxml_Affix_s*)y->gg.g.n;
    y->gg.g.n = &x->Affix->gg.g;
    x->Affix = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_Affix) */

void zx_hrxml_ContactName_PUT_Affix(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  y = x->Affix;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Affix = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_Affix) */

void zx_hrxml_ContactName_ADD_Affix(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Affix->gg.g;
    x->Affix = z;
    return;
  case -1:
    y = x->Affix;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactName_DEL_Affix) */

void zx_hrxml_ContactName_DEL_Affix(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Affix = (struct zx_hrxml_Affix_s*)x->Affix->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Affix_s*)x->Affix;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ContactName_NUM_AlternateScript) */

int zx_hrxml_ContactName_NUM_AlternateScript(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_AlternateScript_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AlternateScript; y; ++n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ContactName_GET_AlternateScript) */

struct zx_hrxml_AlternateScript_s* zx_hrxml_ContactName_GET_AlternateScript(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return 0;
  for (y = x->AlternateScript; n>=0 && y; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ContactName_POP_AlternateScript) */

struct zx_hrxml_AlternateScript_s* zx_hrxml_ContactName_POP_AlternateScript(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return 0;
  y = x->AlternateScript;
  if (y)
    x->AlternateScript = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ContactName_PUSH_AlternateScript) */

void zx_hrxml_ContactName_PUSH_AlternateScript(struct zx_hrxml_ContactName_s* x, struct zx_hrxml_AlternateScript_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AlternateScript->gg.g;
  x->AlternateScript = z;
}

/* FUNC(zx_hrxml_ContactName_REV_AlternateScript) */

void zx_hrxml_ContactName_REV_AlternateScript(struct zx_hrxml_ContactName_s* x)
{
  struct zx_hrxml_AlternateScript_s* nxt;
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return;
  y = x->AlternateScript;
  if (!y) return;
  x->AlternateScript = 0;
  while (y) {
    nxt = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n;
    y->gg.g.n = &x->AlternateScript->gg.g;
    x->AlternateScript = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ContactName_PUT_AlternateScript) */

void zx_hrxml_ContactName_PUT_AlternateScript(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_AlternateScript_s* z)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x || !z) return;
  y = x->AlternateScript;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AlternateScript = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ContactName_ADD_AlternateScript) */

void zx_hrxml_ContactName_ADD_AlternateScript(struct zx_hrxml_ContactName_s* x, int n, struct zx_hrxml_AlternateScript_s* z)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AlternateScript->gg.g;
    x->AlternateScript = z;
    return;
  case -1:
    y = x->AlternateScript;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AlternateScript; n > 1 && y; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ContactName_DEL_AlternateScript) */

void zx_hrxml_ContactName_DEL_AlternateScript(struct zx_hrxml_ContactName_s* x, int n)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AlternateScript = (struct zx_hrxml_AlternateScript_s*)x->AlternateScript->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AlternateScript_s*)x->AlternateScript;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AlternateScript; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ContactName_GET_script) */
struct zx_str* zx_hrxml_ContactName_GET_script(struct zx_hrxml_ContactName_s* x) { return x->script; }
/* FUNC(zx_hrxml_ContactName_PUT_script) */
void zx_hrxml_ContactName_PUT_script(struct zx_hrxml_ContactName_s* x, struct zx_str* y) { x->script = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Copyright_NUM_CopyrightDates) */

int zx_hrxml_Copyright_NUM_CopyrightDates(struct zx_hrxml_Copyright_s* x)
{
  struct zx_hrxml_CopyrightDates_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CopyrightDates; y; ++n, y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Copyright_GET_CopyrightDates) */

struct zx_hrxml_CopyrightDates_s* zx_hrxml_Copyright_GET_CopyrightDates(struct zx_hrxml_Copyright_s* x, int n)
{
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x) return 0;
  for (y = x->CopyrightDates; n>=0 && y; --n, y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Copyright_POP_CopyrightDates) */

struct zx_hrxml_CopyrightDates_s* zx_hrxml_Copyright_POP_CopyrightDates(struct zx_hrxml_Copyright_s* x)
{
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x) return 0;
  y = x->CopyrightDates;
  if (y)
    x->CopyrightDates = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Copyright_PUSH_CopyrightDates) */

void zx_hrxml_Copyright_PUSH_CopyrightDates(struct zx_hrxml_Copyright_s* x, struct zx_hrxml_CopyrightDates_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CopyrightDates->gg.g;
  x->CopyrightDates = z;
}

/* FUNC(zx_hrxml_Copyright_REV_CopyrightDates) */

void zx_hrxml_Copyright_REV_CopyrightDates(struct zx_hrxml_Copyright_s* x)
{
  struct zx_hrxml_CopyrightDates_s* nxt;
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x) return;
  y = x->CopyrightDates;
  if (!y) return;
  x->CopyrightDates = 0;
  while (y) {
    nxt = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n;
    y->gg.g.n = &x->CopyrightDates->gg.g;
    x->CopyrightDates = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Copyright_PUT_CopyrightDates) */

void zx_hrxml_Copyright_PUT_CopyrightDates(struct zx_hrxml_Copyright_s* x, int n, struct zx_hrxml_CopyrightDates_s* z)
{
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x || !z) return;
  y = x->CopyrightDates;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CopyrightDates = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Copyright_ADD_CopyrightDates) */

void zx_hrxml_Copyright_ADD_CopyrightDates(struct zx_hrxml_Copyright_s* x, int n, struct zx_hrxml_CopyrightDates_s* z)
{
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CopyrightDates->gg.g;
    x->CopyrightDates = z;
    return;
  case -1:
    y = x->CopyrightDates;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CopyrightDates; n > 1 && y; --n, y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Copyright_DEL_CopyrightDates) */

void zx_hrxml_Copyright_DEL_CopyrightDates(struct zx_hrxml_Copyright_s* x, int n)
{
  struct zx_hrxml_CopyrightDates_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CopyrightDates = (struct zx_hrxml_CopyrightDates_s*)x->CopyrightDates->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CopyrightDates_s*)x->CopyrightDates;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CopyrightDates; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CopyrightDates_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Copyright_NUM_CopyrightText) */

int zx_hrxml_Copyright_NUM_CopyrightText(struct zx_hrxml_Copyright_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CopyrightText; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Copyright_GET_CopyrightText) */

struct zx_elem_s* zx_hrxml_Copyright_GET_CopyrightText(struct zx_hrxml_Copyright_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CopyrightText; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Copyright_POP_CopyrightText) */

struct zx_elem_s* zx_hrxml_Copyright_POP_CopyrightText(struct zx_hrxml_Copyright_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CopyrightText;
  if (y)
    x->CopyrightText = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Copyright_PUSH_CopyrightText) */

void zx_hrxml_Copyright_PUSH_CopyrightText(struct zx_hrxml_Copyright_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CopyrightText->g;
  x->CopyrightText = z;
}

/* FUNC(zx_hrxml_Copyright_REV_CopyrightText) */

void zx_hrxml_Copyright_REV_CopyrightText(struct zx_hrxml_Copyright_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CopyrightText;
  if (!y) return;
  x->CopyrightText = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CopyrightText->g;
    x->CopyrightText = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Copyright_PUT_CopyrightText) */

void zx_hrxml_Copyright_PUT_CopyrightText(struct zx_hrxml_Copyright_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CopyrightText;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CopyrightText = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Copyright_ADD_CopyrightText) */

void zx_hrxml_Copyright_ADD_CopyrightText(struct zx_hrxml_Copyright_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CopyrightText->g;
    x->CopyrightText = z;
    return;
  case -1:
    y = x->CopyrightText;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CopyrightText; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Copyright_DEL_CopyrightText) */

void zx_hrxml_Copyright_DEL_CopyrightText(struct zx_hrxml_Copyright_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CopyrightText = (struct zx_elem_s*)x->CopyrightText->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CopyrightText;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CopyrightText; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CopyrightDates_NUM_OriginalDate) */

int zx_hrxml_CopyrightDates_NUM_OriginalDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_OriginalDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OriginalDate; y; ++n, y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CopyrightDates_GET_OriginalDate) */

struct zx_hrxml_OriginalDate_s* zx_hrxml_CopyrightDates_GET_OriginalDate(struct zx_hrxml_CopyrightDates_s* x, int n)
{
  struct zx_hrxml_OriginalDate_s* y;
  if (!x) return 0;
  for (y = x->OriginalDate; n>=0 && y; --n, y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CopyrightDates_POP_OriginalDate) */

struct zx_hrxml_OriginalDate_s* zx_hrxml_CopyrightDates_POP_OriginalDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_OriginalDate_s* y;
  if (!x) return 0;
  y = x->OriginalDate;
  if (y)
    x->OriginalDate = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CopyrightDates_PUSH_OriginalDate) */

void zx_hrxml_CopyrightDates_PUSH_OriginalDate(struct zx_hrxml_CopyrightDates_s* x, struct zx_hrxml_OriginalDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OriginalDate->gg.g;
  x->OriginalDate = z;
}

/* FUNC(zx_hrxml_CopyrightDates_REV_OriginalDate) */

void zx_hrxml_CopyrightDates_REV_OriginalDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_OriginalDate_s* nxt;
  struct zx_hrxml_OriginalDate_s* y;
  if (!x) return;
  y = x->OriginalDate;
  if (!y) return;
  x->OriginalDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n;
    y->gg.g.n = &x->OriginalDate->gg.g;
    x->OriginalDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CopyrightDates_PUT_OriginalDate) */

void zx_hrxml_CopyrightDates_PUT_OriginalDate(struct zx_hrxml_CopyrightDates_s* x, int n, struct zx_hrxml_OriginalDate_s* z)
{
  struct zx_hrxml_OriginalDate_s* y;
  if (!x || !z) return;
  y = x->OriginalDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OriginalDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CopyrightDates_ADD_OriginalDate) */

void zx_hrxml_CopyrightDates_ADD_OriginalDate(struct zx_hrxml_CopyrightDates_s* x, int n, struct zx_hrxml_OriginalDate_s* z)
{
  struct zx_hrxml_OriginalDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OriginalDate->gg.g;
    x->OriginalDate = z;
    return;
  case -1:
    y = x->OriginalDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OriginalDate; n > 1 && y; --n, y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CopyrightDates_DEL_OriginalDate) */

void zx_hrxml_CopyrightDates_DEL_OriginalDate(struct zx_hrxml_CopyrightDates_s* x, int n)
{
  struct zx_hrxml_OriginalDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OriginalDate = (struct zx_hrxml_OriginalDate_s*)x->OriginalDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OriginalDate_s*)x->OriginalDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OriginalDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OriginalDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_CopyrightDates_NUM_MostRecentDate) */

int zx_hrxml_CopyrightDates_NUM_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_MostRecentDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MostRecentDate; y; ++n, y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_CopyrightDates_GET_MostRecentDate) */

struct zx_hrxml_MostRecentDate_s* zx_hrxml_CopyrightDates_GET_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x, int n)
{
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x) return 0;
  for (y = x->MostRecentDate; n>=0 && y; --n, y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_CopyrightDates_POP_MostRecentDate) */

struct zx_hrxml_MostRecentDate_s* zx_hrxml_CopyrightDates_POP_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x) return 0;
  y = x->MostRecentDate;
  if (y)
    x->MostRecentDate = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_CopyrightDates_PUSH_MostRecentDate) */

void zx_hrxml_CopyrightDates_PUSH_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x, struct zx_hrxml_MostRecentDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->MostRecentDate->gg.g;
  x->MostRecentDate = z;
}

/* FUNC(zx_hrxml_CopyrightDates_REV_MostRecentDate) */

void zx_hrxml_CopyrightDates_REV_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x)
{
  struct zx_hrxml_MostRecentDate_s* nxt;
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x) return;
  y = x->MostRecentDate;
  if (!y) return;
  x->MostRecentDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n;
    y->gg.g.n = &x->MostRecentDate->gg.g;
    x->MostRecentDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_CopyrightDates_PUT_MostRecentDate) */

void zx_hrxml_CopyrightDates_PUT_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x, int n, struct zx_hrxml_MostRecentDate_s* z)
{
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x || !z) return;
  y = x->MostRecentDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->MostRecentDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_CopyrightDates_ADD_MostRecentDate) */

void zx_hrxml_CopyrightDates_ADD_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x, int n, struct zx_hrxml_MostRecentDate_s* z)
{
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->MostRecentDate->gg.g;
    x->MostRecentDate = z;
    return;
  case -1:
    y = x->MostRecentDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MostRecentDate; n > 1 && y; --n, y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_CopyrightDates_DEL_MostRecentDate) */

void zx_hrxml_CopyrightDates_DEL_MostRecentDate(struct zx_hrxml_CopyrightDates_s* x, int n)
{
  struct zx_hrxml_MostRecentDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MostRecentDate = (struct zx_hrxml_MostRecentDate_s*)x->MostRecentDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_MostRecentDate_s*)x->MostRecentDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MostRecentDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MostRecentDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DatesOfAttendance_NUM_StartDate) */

int zx_hrxml_DatesOfAttendance_NUM_StartDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DatesOfAttendance_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_DatesOfAttendance_GET_StartDate(struct zx_hrxml_DatesOfAttendance_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DatesOfAttendance_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_DatesOfAttendance_POP_StartDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DatesOfAttendance_PUSH_StartDate) */

void zx_hrxml_DatesOfAttendance_PUSH_StartDate(struct zx_hrxml_DatesOfAttendance_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_DatesOfAttendance_REV_StartDate) */

void zx_hrxml_DatesOfAttendance_REV_StartDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DatesOfAttendance_PUT_StartDate) */

void zx_hrxml_DatesOfAttendance_PUT_StartDate(struct zx_hrxml_DatesOfAttendance_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DatesOfAttendance_ADD_StartDate) */

void zx_hrxml_DatesOfAttendance_ADD_StartDate(struct zx_hrxml_DatesOfAttendance_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DatesOfAttendance_DEL_StartDate) */

void zx_hrxml_DatesOfAttendance_DEL_StartDate(struct zx_hrxml_DatesOfAttendance_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DatesOfAttendance_NUM_EndDate) */

int zx_hrxml_DatesOfAttendance_NUM_EndDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DatesOfAttendance_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_DatesOfAttendance_GET_EndDate(struct zx_hrxml_DatesOfAttendance_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DatesOfAttendance_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_DatesOfAttendance_POP_EndDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DatesOfAttendance_PUSH_EndDate) */

void zx_hrxml_DatesOfAttendance_PUSH_EndDate(struct zx_hrxml_DatesOfAttendance_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_DatesOfAttendance_REV_EndDate) */

void zx_hrxml_DatesOfAttendance_REV_EndDate(struct zx_hrxml_DatesOfAttendance_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DatesOfAttendance_PUT_EndDate) */

void zx_hrxml_DatesOfAttendance_PUT_EndDate(struct zx_hrxml_DatesOfAttendance_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DatesOfAttendance_ADD_EndDate) */

void zx_hrxml_DatesOfAttendance_ADD_EndDate(struct zx_hrxml_DatesOfAttendance_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DatesOfAttendance_DEL_EndDate) */

void zx_hrxml_DatesOfAttendance_DEL_EndDate(struct zx_hrxml_DatesOfAttendance_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_DatesOfAttendance_GET_currentlyEnrolled) */
struct zx_str* zx_hrxml_DatesOfAttendance_GET_currentlyEnrolled(struct zx_hrxml_DatesOfAttendance_s* x) { return x->currentlyEnrolled; }
/* FUNC(zx_hrxml_DatesOfAttendance_PUT_currentlyEnrolled) */
void zx_hrxml_DatesOfAttendance_PUT_currentlyEnrolled(struct zx_hrxml_DatesOfAttendance_s* x, struct zx_str* y) { x->currentlyEnrolled = y; }
/* FUNC(zx_hrxml_DatesOfAttendance_GET_enrollmentStatus) */
struct zx_str* zx_hrxml_DatesOfAttendance_GET_enrollmentStatus(struct zx_hrxml_DatesOfAttendance_s* x) { return x->enrollmentStatus; }
/* FUNC(zx_hrxml_DatesOfAttendance_PUT_enrollmentStatus) */
void zx_hrxml_DatesOfAttendance_PUT_enrollmentStatus(struct zx_hrxml_DatesOfAttendance_s* x, struct zx_str* y) { x->enrollmentStatus = y; }
/* FUNC(zx_hrxml_DatesOfAttendance_GET_studentInGoodStanding) */
struct zx_str* zx_hrxml_DatesOfAttendance_GET_studentInGoodStanding(struct zx_hrxml_DatesOfAttendance_s* x) { return x->studentInGoodStanding; }
/* FUNC(zx_hrxml_DatesOfAttendance_PUT_studentInGoodStanding) */
void zx_hrxml_DatesOfAttendance_PUT_studentInGoodStanding(struct zx_hrxml_DatesOfAttendance_s* x, struct zx_str* y) { x->studentInGoodStanding = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DatesOfService_NUM_StartDate) */

int zx_hrxml_DatesOfService_NUM_StartDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DatesOfService_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_DatesOfService_GET_StartDate(struct zx_hrxml_DatesOfService_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DatesOfService_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_DatesOfService_POP_StartDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DatesOfService_PUSH_StartDate) */

void zx_hrxml_DatesOfService_PUSH_StartDate(struct zx_hrxml_DatesOfService_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_DatesOfService_REV_StartDate) */

void zx_hrxml_DatesOfService_REV_StartDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DatesOfService_PUT_StartDate) */

void zx_hrxml_DatesOfService_PUT_StartDate(struct zx_hrxml_DatesOfService_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DatesOfService_ADD_StartDate) */

void zx_hrxml_DatesOfService_ADD_StartDate(struct zx_hrxml_DatesOfService_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DatesOfService_DEL_StartDate) */

void zx_hrxml_DatesOfService_DEL_StartDate(struct zx_hrxml_DatesOfService_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DatesOfService_NUM_EndDate) */

int zx_hrxml_DatesOfService_NUM_EndDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DatesOfService_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_DatesOfService_GET_EndDate(struct zx_hrxml_DatesOfService_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DatesOfService_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_DatesOfService_POP_EndDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DatesOfService_PUSH_EndDate) */

void zx_hrxml_DatesOfService_PUSH_EndDate(struct zx_hrxml_DatesOfService_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_DatesOfService_REV_EndDate) */

void zx_hrxml_DatesOfService_REV_EndDate(struct zx_hrxml_DatesOfService_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DatesOfService_PUT_EndDate) */

void zx_hrxml_DatesOfService_PUT_EndDate(struct zx_hrxml_DatesOfService_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DatesOfService_ADD_EndDate) */

void zx_hrxml_DatesOfService_ADD_EndDate(struct zx_hrxml_DatesOfService_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DatesOfService_DEL_EndDate) */

void zx_hrxml_DatesOfService_DEL_EndDate(struct zx_hrxml_DatesOfService_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeName) */

int zx_hrxml_Degree_NUM_DegreeName(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeName; y; ++n, y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeName) */

struct zx_hrxml_DegreeName_s* zx_hrxml_Degree_GET_DegreeName(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeName_s* y;
  if (!x) return 0;
  for (y = x->DegreeName; n>=0 && y; --n, y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeName) */

struct zx_hrxml_DegreeName_s* zx_hrxml_Degree_POP_DegreeName(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeName_s* y;
  if (!x) return 0;
  y = x->DegreeName;
  if (y)
    x->DegreeName = (struct zx_hrxml_DegreeName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeName) */

void zx_hrxml_Degree_PUSH_DegreeName(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeName->gg.g;
  x->DegreeName = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeName) */

void zx_hrxml_Degree_REV_DegreeName(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeName_s* nxt;
  struct zx_hrxml_DegreeName_s* y;
  if (!x) return;
  y = x->DegreeName;
  if (!y) return;
  x->DegreeName = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeName_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeName->gg.g;
    x->DegreeName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeName) */

void zx_hrxml_Degree_PUT_DegreeName(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeName_s* z)
{
  struct zx_hrxml_DegreeName_s* y;
  if (!x || !z) return;
  y = x->DegreeName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeName) */

void zx_hrxml_Degree_ADD_DegreeName(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeName_s* z)
{
  struct zx_hrxml_DegreeName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeName->gg.g;
    x->DegreeName = z;
    return;
  case -1:
    y = x->DegreeName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeName; n > 1 && y; --n, y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeName) */

void zx_hrxml_Degree_DEL_DegreeName(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeName = (struct zx_hrxml_DegreeName_s*)x->DegreeName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeName_s*)x->DegreeName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeDate) */

int zx_hrxml_Degree_NUM_DegreeDate(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeDate; y; ++n, y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeDate) */

struct zx_hrxml_DegreeDate_s* zx_hrxml_Degree_GET_DegreeDate(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeDate_s* y;
  if (!x) return 0;
  for (y = x->DegreeDate; n>=0 && y; --n, y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeDate) */

struct zx_hrxml_DegreeDate_s* zx_hrxml_Degree_POP_DegreeDate(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeDate_s* y;
  if (!x) return 0;
  y = x->DegreeDate;
  if (y)
    x->DegreeDate = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeDate) */

void zx_hrxml_Degree_PUSH_DegreeDate(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeDate->gg.g;
  x->DegreeDate = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeDate) */

void zx_hrxml_Degree_REV_DegreeDate(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeDate_s* nxt;
  struct zx_hrxml_DegreeDate_s* y;
  if (!x) return;
  y = x->DegreeDate;
  if (!y) return;
  x->DegreeDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeDate->gg.g;
    x->DegreeDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeDate) */

void zx_hrxml_Degree_PUT_DegreeDate(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeDate_s* z)
{
  struct zx_hrxml_DegreeDate_s* y;
  if (!x || !z) return;
  y = x->DegreeDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeDate) */

void zx_hrxml_Degree_ADD_DegreeDate(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeDate_s* z)
{
  struct zx_hrxml_DegreeDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeDate->gg.g;
    x->DegreeDate = z;
    return;
  case -1:
    y = x->DegreeDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeDate; n > 1 && y; --n, y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeDate) */

void zx_hrxml_Degree_DEL_DegreeDate(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeDate = (struct zx_hrxml_DegreeDate_s*)x->DegreeDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeDate_s*)x->DegreeDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_OtherHonors) */

int zx_hrxml_Degree_NUM_OtherHonors(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_OtherHonors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherHonors; y; ++n, y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_OtherHonors) */

struct zx_hrxml_OtherHonors_s* zx_hrxml_Degree_GET_OtherHonors(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_OtherHonors_s* y;
  if (!x) return 0;
  for (y = x->OtherHonors; n>=0 && y; --n, y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_OtherHonors) */

struct zx_hrxml_OtherHonors_s* zx_hrxml_Degree_POP_OtherHonors(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_OtherHonors_s* y;
  if (!x) return 0;
  y = x->OtherHonors;
  if (y)
    x->OtherHonors = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_OtherHonors) */

void zx_hrxml_Degree_PUSH_OtherHonors(struct zx_hrxml_Degree_s* x, struct zx_hrxml_OtherHonors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherHonors->gg.g;
  x->OtherHonors = z;
}

/* FUNC(zx_hrxml_Degree_REV_OtherHonors) */

void zx_hrxml_Degree_REV_OtherHonors(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_OtherHonors_s* nxt;
  struct zx_hrxml_OtherHonors_s* y;
  if (!x) return;
  y = x->OtherHonors;
  if (!y) return;
  x->OtherHonors = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherHonors->gg.g;
    x->OtherHonors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_OtherHonors) */

void zx_hrxml_Degree_PUT_OtherHonors(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_OtherHonors_s* z)
{
  struct zx_hrxml_OtherHonors_s* y;
  if (!x || !z) return;
  y = x->OtherHonors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherHonors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_OtherHonors) */

void zx_hrxml_Degree_ADD_OtherHonors(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_OtherHonors_s* z)
{
  struct zx_hrxml_OtherHonors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherHonors->gg.g;
    x->OtherHonors = z;
    return;
  case -1:
    y = x->OtherHonors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherHonors; n > 1 && y; --n, y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_OtherHonors) */

void zx_hrxml_Degree_DEL_OtherHonors(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_OtherHonors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherHonors = (struct zx_hrxml_OtherHonors_s*)x->OtherHonors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherHonors_s*)x->OtherHonors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherHonors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherHonors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeMajor) */

int zx_hrxml_Degree_NUM_DegreeMajor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMajor_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeMajor; y; ++n, y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeMajor) */

struct zx_hrxml_DegreeMajor_s* zx_hrxml_Degree_GET_DegreeMajor(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x) return 0;
  for (y = x->DegreeMajor; n>=0 && y; --n, y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeMajor) */

struct zx_hrxml_DegreeMajor_s* zx_hrxml_Degree_POP_DegreeMajor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x) return 0;
  y = x->DegreeMajor;
  if (y)
    x->DegreeMajor = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeMajor) */

void zx_hrxml_Degree_PUSH_DegreeMajor(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeMajor_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeMajor->gg.g;
  x->DegreeMajor = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeMajor) */

void zx_hrxml_Degree_REV_DegreeMajor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMajor_s* nxt;
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x) return;
  y = x->DegreeMajor;
  if (!y) return;
  x->DegreeMajor = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeMajor->gg.g;
    x->DegreeMajor = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeMajor) */

void zx_hrxml_Degree_PUT_DegreeMajor(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMajor_s* z)
{
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x || !z) return;
  y = x->DegreeMajor;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeMajor = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeMajor) */

void zx_hrxml_Degree_ADD_DegreeMajor(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMajor_s* z)
{
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeMajor->gg.g;
    x->DegreeMajor = z;
    return;
  case -1:
    y = x->DegreeMajor;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMajor; n > 1 && y; --n, y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeMajor) */

void zx_hrxml_Degree_DEL_DegreeMajor(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMajor_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeMajor = (struct zx_hrxml_DegreeMajor_s*)x->DegreeMajor->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeMajor_s*)x->DegreeMajor;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMajor; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMajor_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeMinor) */

int zx_hrxml_Degree_NUM_DegreeMinor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMinor_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeMinor; y; ++n, y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeMinor) */

struct zx_hrxml_DegreeMinor_s* zx_hrxml_Degree_GET_DegreeMinor(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x) return 0;
  for (y = x->DegreeMinor; n>=0 && y; --n, y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeMinor) */

struct zx_hrxml_DegreeMinor_s* zx_hrxml_Degree_POP_DegreeMinor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x) return 0;
  y = x->DegreeMinor;
  if (y)
    x->DegreeMinor = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeMinor) */

void zx_hrxml_Degree_PUSH_DegreeMinor(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeMinor_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeMinor->gg.g;
  x->DegreeMinor = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeMinor) */

void zx_hrxml_Degree_REV_DegreeMinor(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMinor_s* nxt;
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x) return;
  y = x->DegreeMinor;
  if (!y) return;
  x->DegreeMinor = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeMinor->gg.g;
    x->DegreeMinor = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeMinor) */

void zx_hrxml_Degree_PUT_DegreeMinor(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMinor_s* z)
{
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x || !z) return;
  y = x->DegreeMinor;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeMinor = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeMinor) */

void zx_hrxml_Degree_ADD_DegreeMinor(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMinor_s* z)
{
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeMinor->gg.g;
    x->DegreeMinor = z;
    return;
  case -1:
    y = x->DegreeMinor;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMinor; n > 1 && y; --n, y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeMinor) */

void zx_hrxml_Degree_DEL_DegreeMinor(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMinor_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeMinor = (struct zx_hrxml_DegreeMinor_s*)x->DegreeMinor->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeMinor_s*)x->DegreeMinor;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMinor; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMinor_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeMeasure) */

int zx_hrxml_Degree_NUM_DegreeMeasure(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeMeasure; y; ++n, y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeMeasure) */

struct zx_hrxml_DegreeMeasure_s* zx_hrxml_Degree_GET_DegreeMeasure(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x) return 0;
  for (y = x->DegreeMeasure; n>=0 && y; --n, y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeMeasure) */

struct zx_hrxml_DegreeMeasure_s* zx_hrxml_Degree_POP_DegreeMeasure(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x) return 0;
  y = x->DegreeMeasure;
  if (y)
    x->DegreeMeasure = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeMeasure) */

void zx_hrxml_Degree_PUSH_DegreeMeasure(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeMeasure_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeMeasure->gg.g;
  x->DegreeMeasure = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeMeasure) */

void zx_hrxml_Degree_REV_DegreeMeasure(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeMeasure_s* nxt;
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x) return;
  y = x->DegreeMeasure;
  if (!y) return;
  x->DegreeMeasure = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeMeasure->gg.g;
    x->DegreeMeasure = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeMeasure) */

void zx_hrxml_Degree_PUT_DegreeMeasure(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMeasure_s* z)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x || !z) return;
  y = x->DegreeMeasure;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeMeasure = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeMeasure) */

void zx_hrxml_Degree_ADD_DegreeMeasure(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeMeasure_s* z)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeMeasure->gg.g;
    x->DegreeMeasure = z;
    return;
  case -1:
    y = x->DegreeMeasure;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMeasure; n > 1 && y; --n, y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeMeasure) */

void zx_hrxml_Degree_DEL_DegreeMeasure(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeMeasure_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeMeasure = (struct zx_hrxml_DegreeMeasure_s*)x->DegreeMeasure->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeMeasure_s*)x->DegreeMeasure;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeMeasure; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeMeasure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DatesOfAttendance) */

int zx_hrxml_Degree_NUM_DatesOfAttendance(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DatesOfAttendance; y; ++n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DatesOfAttendance) */

struct zx_hrxml_DatesOfAttendance_s* zx_hrxml_Degree_GET_DatesOfAttendance(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return 0;
  for (y = x->DatesOfAttendance; n>=0 && y; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DatesOfAttendance) */

struct zx_hrxml_DatesOfAttendance_s* zx_hrxml_Degree_POP_DatesOfAttendance(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return 0;
  y = x->DatesOfAttendance;
  if (y)
    x->DatesOfAttendance = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DatesOfAttendance) */

void zx_hrxml_Degree_PUSH_DatesOfAttendance(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DatesOfAttendance_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DatesOfAttendance->gg.g;
  x->DatesOfAttendance = z;
}

/* FUNC(zx_hrxml_Degree_REV_DatesOfAttendance) */

void zx_hrxml_Degree_REV_DatesOfAttendance(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* nxt;
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return;
  y = x->DatesOfAttendance;
  if (!y) return;
  x->DatesOfAttendance = 0;
  while (y) {
    nxt = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n;
    y->gg.g.n = &x->DatesOfAttendance->gg.g;
    x->DatesOfAttendance = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DatesOfAttendance) */

void zx_hrxml_Degree_PUT_DatesOfAttendance(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DatesOfAttendance_s* z)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x || !z) return;
  y = x->DatesOfAttendance;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DatesOfAttendance = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DatesOfAttendance) */

void zx_hrxml_Degree_ADD_DatesOfAttendance(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DatesOfAttendance_s* z)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DatesOfAttendance->gg.g;
    x->DatesOfAttendance = z;
    return;
  case -1:
    y = x->DatesOfAttendance;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfAttendance; n > 1 && y; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DatesOfAttendance) */

void zx_hrxml_Degree_DEL_DatesOfAttendance(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DatesOfAttendance = (struct zx_hrxml_DatesOfAttendance_s*)x->DatesOfAttendance->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DatesOfAttendance_s*)x->DatesOfAttendance;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfAttendance; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_Comments) */

int zx_hrxml_Degree_NUM_Comments(struct zx_hrxml_Degree_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_Comments) */

struct zx_elem_s* zx_hrxml_Degree_GET_Comments(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_Comments) */

struct zx_elem_s* zx_hrxml_Degree_POP_Comments(struct zx_hrxml_Degree_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_Comments) */

void zx_hrxml_Degree_PUSH_Comments(struct zx_hrxml_Degree_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Degree_REV_Comments) */

void zx_hrxml_Degree_REV_Comments(struct zx_hrxml_Degree_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_Comments) */

void zx_hrxml_Degree_PUT_Comments(struct zx_hrxml_Degree_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_Comments) */

void zx_hrxml_Degree_ADD_Comments(struct zx_hrxml_Degree_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Degree_DEL_Comments) */

void zx_hrxml_Degree_DEL_Comments(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_DegreeClassification) */

int zx_hrxml_Degree_NUM_DegreeClassification(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeClassification_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeClassification; y; ++n, y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_DegreeClassification) */

struct zx_hrxml_DegreeClassification_s* zx_hrxml_Degree_GET_DegreeClassification(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x) return 0;
  for (y = x->DegreeClassification; n>=0 && y; --n, y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_DegreeClassification) */

struct zx_hrxml_DegreeClassification_s* zx_hrxml_Degree_POP_DegreeClassification(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x) return 0;
  y = x->DegreeClassification;
  if (y)
    x->DegreeClassification = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_DegreeClassification) */

void zx_hrxml_Degree_PUSH_DegreeClassification(struct zx_hrxml_Degree_s* x, struct zx_hrxml_DegreeClassification_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DegreeClassification->gg.g;
  x->DegreeClassification = z;
}

/* FUNC(zx_hrxml_Degree_REV_DegreeClassification) */

void zx_hrxml_Degree_REV_DegreeClassification(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_DegreeClassification_s* nxt;
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x) return;
  y = x->DegreeClassification;
  if (!y) return;
  x->DegreeClassification = 0;
  while (y) {
    nxt = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n;
    y->gg.g.n = &x->DegreeClassification->gg.g;
    x->DegreeClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_DegreeClassification) */

void zx_hrxml_Degree_PUT_DegreeClassification(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeClassification_s* z)
{
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x || !z) return;
  y = x->DegreeClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DegreeClassification = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_DegreeClassification) */

void zx_hrxml_Degree_ADD_DegreeClassification(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_DegreeClassification_s* z)
{
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DegreeClassification->gg.g;
    x->DegreeClassification = z;
    return;
  case -1:
    y = x->DegreeClassification;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeClassification; n > 1 && y; --n, y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_DegreeClassification) */

void zx_hrxml_Degree_DEL_DegreeClassification(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_DegreeClassification_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeClassification = (struct zx_hrxml_DegreeClassification_s*)x->DegreeClassification->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DegreeClassification_s*)x->DegreeClassification;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DegreeClassification; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DegreeClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Degree_NUM_UserArea) */

int zx_hrxml_Degree_NUM_UserArea(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Degree_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Degree_GET_UserArea(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Degree_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Degree_POP_UserArea(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Degree_PUSH_UserArea) */

void zx_hrxml_Degree_PUSH_UserArea(struct zx_hrxml_Degree_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_Degree_REV_UserArea) */

void zx_hrxml_Degree_REV_UserArea(struct zx_hrxml_Degree_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Degree_PUT_UserArea) */

void zx_hrxml_Degree_PUT_UserArea(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Degree_ADD_UserArea) */

void zx_hrxml_Degree_ADD_UserArea(struct zx_hrxml_Degree_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Degree_DEL_UserArea) */

void zx_hrxml_Degree_DEL_UserArea(struct zx_hrxml_Degree_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Degree_GET_degreeType) */
struct zx_str* zx_hrxml_Degree_GET_degreeType(struct zx_hrxml_Degree_s* x) { return x->degreeType; }
/* FUNC(zx_hrxml_Degree_PUT_degreeType) */
void zx_hrxml_Degree_PUT_degreeType(struct zx_hrxml_Degree_s* x, struct zx_str* y) { x->degreeType = y; }
/* FUNC(zx_hrxml_Degree_GET_examPassed) */
struct zx_str* zx_hrxml_Degree_GET_examPassed(struct zx_hrxml_Degree_s* x) { return x->examPassed; }
/* FUNC(zx_hrxml_Degree_PUT_examPassed) */
void zx_hrxml_Degree_PUT_examPassed(struct zx_hrxml_Degree_s* x, struct zx_str* y) { x->examPassed = y; }
/* FUNC(zx_hrxml_Degree_GET_graduatingDegree) */
struct zx_str* zx_hrxml_Degree_GET_graduatingDegree(struct zx_hrxml_Degree_s* x) { return x->graduatingDegree; }
/* FUNC(zx_hrxml_Degree_PUT_graduatingDegree) */
void zx_hrxml_Degree_PUT_graduatingDegree(struct zx_hrxml_Degree_s* x, struct zx_str* y) { x->graduatingDegree = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeClassification_NUM_Id) */

int zx_hrxml_DegreeClassification_NUM_Id(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeClassification_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_DegreeClassification_GET_Id(struct zx_hrxml_DegreeClassification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeClassification_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_DegreeClassification_POP_Id(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeClassification_PUSH_Id) */

void zx_hrxml_DegreeClassification_PUSH_Id(struct zx_hrxml_DegreeClassification_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_DegreeClassification_REV_Id) */

void zx_hrxml_DegreeClassification_REV_Id(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeClassification_PUT_Id) */

void zx_hrxml_DegreeClassification_PUT_Id(struct zx_hrxml_DegreeClassification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeClassification_ADD_Id) */

void zx_hrxml_DegreeClassification_ADD_Id(struct zx_hrxml_DegreeClassification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeClassification_DEL_Id) */

void zx_hrxml_DegreeClassification_DEL_Id(struct zx_hrxml_DegreeClassification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeClassification_NUM_Description) */

int zx_hrxml_DegreeClassification_NUM_Description(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeClassification_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_DegreeClassification_GET_Description(struct zx_hrxml_DegreeClassification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeClassification_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_DegreeClassification_POP_Description(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeClassification_PUSH_Description) */

void zx_hrxml_DegreeClassification_PUSH_Description(struct zx_hrxml_DegreeClassification_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_DegreeClassification_REV_Description) */

void zx_hrxml_DegreeClassification_REV_Description(struct zx_hrxml_DegreeClassification_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeClassification_PUT_Description) */

void zx_hrxml_DegreeClassification_PUT_Description(struct zx_hrxml_DegreeClassification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeClassification_ADD_Description) */

void zx_hrxml_DegreeClassification_ADD_Description(struct zx_hrxml_DegreeClassification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeClassification_DEL_Description) */

void zx_hrxml_DegreeClassification_DEL_Description(struct zx_hrxml_DegreeClassification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeDate_NUM_AnyDate) */

int zx_hrxml_DegreeDate_NUM_AnyDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_DegreeDate_GET_AnyDate(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_DegreeDate_POP_AnyDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_PUSH_AnyDate) */

void zx_hrxml_DegreeDate_PUSH_AnyDate(struct zx_hrxml_DegreeDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_DegreeDate_REV_AnyDate) */

void zx_hrxml_DegreeDate_REV_AnyDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeDate_PUT_AnyDate) */

void zx_hrxml_DegreeDate_PUT_AnyDate(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeDate_ADD_AnyDate) */

void zx_hrxml_DegreeDate_ADD_AnyDate(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeDate_DEL_AnyDate) */

void zx_hrxml_DegreeDate_DEL_AnyDate(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeDate_NUM_YearMonth) */

int zx_hrxml_DegreeDate_NUM_YearMonth(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_DegreeDate_GET_YearMonth(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_DegreeDate_POP_YearMonth(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_PUSH_YearMonth) */

void zx_hrxml_DegreeDate_PUSH_YearMonth(struct zx_hrxml_DegreeDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_DegreeDate_REV_YearMonth) */

void zx_hrxml_DegreeDate_REV_YearMonth(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeDate_PUT_YearMonth) */

void zx_hrxml_DegreeDate_PUT_YearMonth(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeDate_ADD_YearMonth) */

void zx_hrxml_DegreeDate_ADD_YearMonth(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeDate_DEL_YearMonth) */

void zx_hrxml_DegreeDate_DEL_YearMonth(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeDate_NUM_Year) */

int zx_hrxml_DegreeDate_NUM_Year(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeDate_GET_Year) */

struct zx_elem_s* zx_hrxml_DegreeDate_GET_Year(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_POP_Year) */

struct zx_elem_s* zx_hrxml_DegreeDate_POP_Year(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_PUSH_Year) */

void zx_hrxml_DegreeDate_PUSH_Year(struct zx_hrxml_DegreeDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_DegreeDate_REV_Year) */

void zx_hrxml_DegreeDate_REV_Year(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeDate_PUT_Year) */

void zx_hrxml_DegreeDate_PUT_Year(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeDate_ADD_Year) */

void zx_hrxml_DegreeDate_ADD_Year(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeDate_DEL_Year) */

void zx_hrxml_DegreeDate_DEL_Year(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeDate_NUM_MonthDay) */

int zx_hrxml_DegreeDate_NUM_MonthDay(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_DegreeDate_GET_MonthDay(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_DegreeDate_POP_MonthDay(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_PUSH_MonthDay) */

void zx_hrxml_DegreeDate_PUSH_MonthDay(struct zx_hrxml_DegreeDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_DegreeDate_REV_MonthDay) */

void zx_hrxml_DegreeDate_REV_MonthDay(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeDate_PUT_MonthDay) */

void zx_hrxml_DegreeDate_PUT_MonthDay(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeDate_ADD_MonthDay) */

void zx_hrxml_DegreeDate_ADD_MonthDay(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeDate_DEL_MonthDay) */

void zx_hrxml_DegreeDate_DEL_MonthDay(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeDate_NUM_StringDate) */

int zx_hrxml_DegreeDate_NUM_StringDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_DegreeDate_GET_StringDate(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_DegreeDate_POP_StringDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeDate_PUSH_StringDate) */

void zx_hrxml_DegreeDate_PUSH_StringDate(struct zx_hrxml_DegreeDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_DegreeDate_REV_StringDate) */

void zx_hrxml_DegreeDate_REV_StringDate(struct zx_hrxml_DegreeDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeDate_PUT_StringDate) */

void zx_hrxml_DegreeDate_PUT_StringDate(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeDate_ADD_StringDate) */

void zx_hrxml_DegreeDate_ADD_StringDate(struct zx_hrxml_DegreeDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeDate_DEL_StringDate) */

void zx_hrxml_DegreeDate_DEL_StringDate(struct zx_hrxml_DegreeDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_DegreeDate_GET_dateDescription) */
struct zx_str* zx_hrxml_DegreeDate_GET_dateDescription(struct zx_hrxml_DegreeDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_DegreeDate_PUT_dateDescription) */
void zx_hrxml_DegreeDate_PUT_dateDescription(struct zx_hrxml_DegreeDate_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMajor_NUM_ProgramId) */

int zx_hrxml_DegreeMajor_NUM_ProgramId(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_hrxml_ProgramId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProgramId; y; ++n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMajor_GET_ProgramId) */

struct zx_hrxml_ProgramId_s* zx_hrxml_DegreeMajor_GET_ProgramId(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return 0;
  for (y = x->ProgramId; n>=0 && y; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_POP_ProgramId) */

struct zx_hrxml_ProgramId_s* zx_hrxml_DegreeMajor_POP_ProgramId(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return 0;
  y = x->ProgramId;
  if (y)
    x->ProgramId = (struct zx_hrxml_ProgramId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_PUSH_ProgramId) */

void zx_hrxml_DegreeMajor_PUSH_ProgramId(struct zx_hrxml_DegreeMajor_s* x, struct zx_hrxml_ProgramId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ProgramId->gg.g;
  x->ProgramId = z;
}

/* FUNC(zx_hrxml_DegreeMajor_REV_ProgramId) */

void zx_hrxml_DegreeMajor_REV_ProgramId(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_hrxml_ProgramId_s* nxt;
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return;
  y = x->ProgramId;
  if (!y) return;
  x->ProgramId = 0;
  while (y) {
    nxt = (struct zx_hrxml_ProgramId_s*)y->gg.g.n;
    y->gg.g.n = &x->ProgramId->gg.g;
    x->ProgramId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_PUT_ProgramId) */

void zx_hrxml_DegreeMajor_PUT_ProgramId(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_hrxml_ProgramId_s* z)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x || !z) return;
  y = x->ProgramId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ProgramId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_ADD_ProgramId) */

void zx_hrxml_DegreeMajor_ADD_ProgramId(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_hrxml_ProgramId_s* z)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ProgramId->gg.g;
    x->ProgramId = z;
    return;
  case -1:
    y = x->ProgramId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProgramId; n > 1 && y; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeMajor_DEL_ProgramId) */

void zx_hrxml_DegreeMajor_DEL_ProgramId(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProgramId = (struct zx_hrxml_ProgramId_s*)x->ProgramId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ProgramId_s*)x->ProgramId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProgramId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMajor_NUM_DegreeConcentration) */

int zx_hrxml_DegreeMajor_NUM_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DegreeConcentration; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMajor_GET_DegreeConcentration) */

struct zx_elem_s* zx_hrxml_DegreeMajor_GET_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DegreeConcentration; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_POP_DegreeConcentration) */

struct zx_elem_s* zx_hrxml_DegreeMajor_POP_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DegreeConcentration;
  if (y)
    x->DegreeConcentration = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_PUSH_DegreeConcentration) */

void zx_hrxml_DegreeMajor_PUSH_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DegreeConcentration->g;
  x->DegreeConcentration = z;
}

/* FUNC(zx_hrxml_DegreeMajor_REV_DegreeConcentration) */

void zx_hrxml_DegreeMajor_REV_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DegreeConcentration;
  if (!y) return;
  x->DegreeConcentration = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DegreeConcentration->g;
    x->DegreeConcentration = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_PUT_DegreeConcentration) */

void zx_hrxml_DegreeMajor_PUT_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DegreeConcentration;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DegreeConcentration = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_ADD_DegreeConcentration) */

void zx_hrxml_DegreeMajor_ADD_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DegreeConcentration->g;
    x->DegreeConcentration = z;
    return;
  case -1:
    y = x->DegreeConcentration;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DegreeConcentration; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMajor_DEL_DegreeConcentration) */

void zx_hrxml_DegreeMajor_DEL_DegreeConcentration(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DegreeConcentration = (struct zx_elem_s*)x->DegreeConcentration->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DegreeConcentration;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DegreeConcentration; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMajor_NUM_Name) */

int zx_hrxml_DegreeMajor_NUM_Name(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMajor_GET_Name) */

struct zx_elem_s* zx_hrxml_DegreeMajor_GET_Name(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_POP_Name) */

struct zx_elem_s* zx_hrxml_DegreeMajor_POP_Name(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_PUSH_Name) */

void zx_hrxml_DegreeMajor_PUSH_Name(struct zx_hrxml_DegreeMajor_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_DegreeMajor_REV_Name) */

void zx_hrxml_DegreeMajor_REV_Name(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_PUT_Name) */

void zx_hrxml_DegreeMajor_PUT_Name(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_ADD_Name) */

void zx_hrxml_DegreeMajor_ADD_Name(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMajor_DEL_Name) */

void zx_hrxml_DegreeMajor_DEL_Name(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMajor_NUM_Option) */

int zx_hrxml_DegreeMajor_NUM_Option(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Option; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMajor_GET_Option) */

struct zx_elem_s* zx_hrxml_DegreeMajor_GET_Option(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Option; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_POP_Option) */

struct zx_elem_s* zx_hrxml_DegreeMajor_POP_Option(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Option;
  if (y)
    x->Option = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMajor_PUSH_Option) */

void zx_hrxml_DegreeMajor_PUSH_Option(struct zx_hrxml_DegreeMajor_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Option->g;
  x->Option = z;
}

/* FUNC(zx_hrxml_DegreeMajor_REV_Option) */

void zx_hrxml_DegreeMajor_REV_Option(struct zx_hrxml_DegreeMajor_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Option;
  if (!y) return;
  x->Option = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Option->g;
    x->Option = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_PUT_Option) */

void zx_hrxml_DegreeMajor_PUT_Option(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Option;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Option = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMajor_ADD_Option) */

void zx_hrxml_DegreeMajor_ADD_Option(struct zx_hrxml_DegreeMajor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Option->g;
    x->Option = z;
    return;
  case -1:
    y = x->Option;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Option; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMajor_DEL_Option) */

void zx_hrxml_DegreeMajor_DEL_Option(struct zx_hrxml_DegreeMajor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Option = (struct zx_elem_s*)x->Option->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Option;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Option; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_EducationalMeasure) */

int zx_hrxml_DegreeMeasure_NUM_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EducationalMeasure; y; ++n, y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_EducationalMeasure) */

struct zx_hrxml_EducationalMeasure_s* zx_hrxml_DegreeMeasure_GET_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x) return 0;
  for (y = x->EducationalMeasure; n>=0 && y; --n, y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_EducationalMeasure) */

struct zx_hrxml_EducationalMeasure_s* zx_hrxml_DegreeMeasure_POP_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x) return 0;
  y = x->EducationalMeasure;
  if (y)
    x->EducationalMeasure = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_EducationalMeasure) */

void zx_hrxml_DegreeMeasure_PUSH_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x, struct zx_hrxml_EducationalMeasure_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EducationalMeasure->gg.g;
  x->EducationalMeasure = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_EducationalMeasure) */

void zx_hrxml_DegreeMeasure_REV_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_EducationalMeasure_s* nxt;
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x) return;
  y = x->EducationalMeasure;
  if (!y) return;
  x->EducationalMeasure = 0;
  while (y) {
    nxt = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n;
    y->gg.g.n = &x->EducationalMeasure->gg.g;
    x->EducationalMeasure = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_EducationalMeasure) */

void zx_hrxml_DegreeMeasure_PUT_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_hrxml_EducationalMeasure_s* z)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x || !z) return;
  y = x->EducationalMeasure;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EducationalMeasure = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_EducationalMeasure) */

void zx_hrxml_DegreeMeasure_ADD_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_hrxml_EducationalMeasure_s* z)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EducationalMeasure->gg.g;
    x->EducationalMeasure = z;
    return;
  case -1:
    y = x->EducationalMeasure;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationalMeasure; n > 1 && y; --n, y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_EducationalMeasure) */

void zx_hrxml_DegreeMeasure_DEL_EducationalMeasure(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_hrxml_EducationalMeasure_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EducationalMeasure = (struct zx_hrxml_EducationalMeasure_s*)x->EducationalMeasure->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EducationalMeasure_s*)x->EducationalMeasure;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationalMeasure; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationalMeasure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_AcademicCreditCode) */

int zx_hrxml_DegreeMeasure_NUM_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AcademicCreditCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_AcademicCreditCode) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AcademicCreditCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_AcademicCreditCode) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AcademicCreditCode;
  if (y)
    x->AcademicCreditCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_AcademicCreditCode) */

void zx_hrxml_DegreeMeasure_PUSH_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AcademicCreditCode->g;
  x->AcademicCreditCode = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_AcademicCreditCode) */

void zx_hrxml_DegreeMeasure_REV_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AcademicCreditCode;
  if (!y) return;
  x->AcademicCreditCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AcademicCreditCode->g;
    x->AcademicCreditCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_AcademicCreditCode) */

void zx_hrxml_DegreeMeasure_PUT_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AcademicCreditCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AcademicCreditCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_AcademicCreditCode) */

void zx_hrxml_DegreeMeasure_ADD_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AcademicCreditCode->g;
    x->AcademicCreditCode = z;
    return;
  case -1:
    y = x->AcademicCreditCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_AcademicCreditCode) */

void zx_hrxml_DegreeMeasure_DEL_AcademicCreditCode(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AcademicCreditCode = (struct zx_elem_s*)x->AcademicCreditCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AcademicCreditCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_CourseLevelCode) */

int zx_hrxml_DegreeMeasure_NUM_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CourseLevelCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_CourseLevelCode) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CourseLevelCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_CourseLevelCode) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CourseLevelCode;
  if (y)
    x->CourseLevelCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_CourseLevelCode) */

void zx_hrxml_DegreeMeasure_PUSH_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CourseLevelCode->g;
  x->CourseLevelCode = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_CourseLevelCode) */

void zx_hrxml_DegreeMeasure_REV_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CourseLevelCode;
  if (!y) return;
  x->CourseLevelCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CourseLevelCode->g;
    x->CourseLevelCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_CourseLevelCode) */

void zx_hrxml_DegreeMeasure_PUT_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CourseLevelCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CourseLevelCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_CourseLevelCode) */

void zx_hrxml_DegreeMeasure_ADD_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CourseLevelCode->g;
    x->CourseLevelCode = z;
    return;
  case -1:
    y = x->CourseLevelCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CourseLevelCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_CourseLevelCode) */

void zx_hrxml_DegreeMeasure_DEL_CourseLevelCode(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CourseLevelCode = (struct zx_elem_s*)x->CourseLevelCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CourseLevelCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CourseLevelCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_CumulativeSummaryIndicator) */

int zx_hrxml_DegreeMeasure_NUM_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CumulativeSummaryIndicator; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_CumulativeSummaryIndicator) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CumulativeSummaryIndicator; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_CumulativeSummaryIndicator) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CumulativeSummaryIndicator;
  if (y)
    x->CumulativeSummaryIndicator = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_CumulativeSummaryIndicator) */

void zx_hrxml_DegreeMeasure_PUSH_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CumulativeSummaryIndicator->g;
  x->CumulativeSummaryIndicator = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_CumulativeSummaryIndicator) */

void zx_hrxml_DegreeMeasure_REV_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CumulativeSummaryIndicator;
  if (!y) return;
  x->CumulativeSummaryIndicator = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CumulativeSummaryIndicator->g;
    x->CumulativeSummaryIndicator = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_CumulativeSummaryIndicator) */

void zx_hrxml_DegreeMeasure_PUT_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CumulativeSummaryIndicator;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CumulativeSummaryIndicator = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_CumulativeSummaryIndicator) */

void zx_hrxml_DegreeMeasure_ADD_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CumulativeSummaryIndicator->g;
    x->CumulativeSummaryIndicator = z;
    return;
  case -1:
    y = x->CumulativeSummaryIndicator;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CumulativeSummaryIndicator; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_CumulativeSummaryIndicator) */

void zx_hrxml_DegreeMeasure_DEL_CumulativeSummaryIndicator(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CumulativeSummaryIndicator = (struct zx_elem_s*)x->CumulativeSummaryIndicator->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CumulativeSummaryIndicator;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CumulativeSummaryIndicator; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursIncluded) */

int zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursIncluded; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursIncluded) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursIncluded; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursIncluded) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AcademicCreditHoursIncluded;
  if (y)
    x->AcademicCreditHoursIncluded = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursIncluded) */

void zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AcademicCreditHoursIncluded->g;
  x->AcademicCreditHoursIncluded = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursIncluded) */

void zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AcademicCreditHoursIncluded;
  if (!y) return;
  x->AcademicCreditHoursIncluded = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AcademicCreditHoursIncluded->g;
    x->AcademicCreditHoursIncluded = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursIncluded) */

void zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AcademicCreditHoursIncluded;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AcademicCreditHoursIncluded = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursIncluded) */

void zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AcademicCreditHoursIncluded->g;
    x->AcademicCreditHoursIncluded = z;
    return;
  case -1:
    y = x->AcademicCreditHoursIncluded;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursIncluded; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursIncluded) */

void zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursIncluded(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AcademicCreditHoursIncluded = (struct zx_elem_s*)x->AcademicCreditHoursIncluded->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AcademicCreditHoursIncluded;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursIncluded; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursAttempted) */

int zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursAttempted; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursAttempted) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursAttempted; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursAttempted) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AcademicCreditHoursAttempted;
  if (y)
    x->AcademicCreditHoursAttempted = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursAttempted) */

void zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AcademicCreditHoursAttempted->g;
  x->AcademicCreditHoursAttempted = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursAttempted) */

void zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AcademicCreditHoursAttempted;
  if (!y) return;
  x->AcademicCreditHoursAttempted = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AcademicCreditHoursAttempted->g;
    x->AcademicCreditHoursAttempted = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursAttempted) */

void zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AcademicCreditHoursAttempted;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AcademicCreditHoursAttempted = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursAttempted) */

void zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AcademicCreditHoursAttempted->g;
    x->AcademicCreditHoursAttempted = z;
    return;
  case -1:
    y = x->AcademicCreditHoursAttempted;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursAttempted; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursAttempted) */

void zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursAttempted(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AcademicCreditHoursAttempted = (struct zx_elem_s*)x->AcademicCreditHoursAttempted->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AcademicCreditHoursAttempted;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursAttempted; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursEarned) */

int zx_hrxml_DegreeMeasure_NUM_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursEarned; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursEarned) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_GET_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AcademicCreditHoursEarned; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursEarned) */

struct zx_elem_s* zx_hrxml_DegreeMeasure_POP_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AcademicCreditHoursEarned;
  if (y)
    x->AcademicCreditHoursEarned = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursEarned) */

void zx_hrxml_DegreeMeasure_PUSH_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AcademicCreditHoursEarned->g;
  x->AcademicCreditHoursEarned = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursEarned) */

void zx_hrxml_DegreeMeasure_REV_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AcademicCreditHoursEarned;
  if (!y) return;
  x->AcademicCreditHoursEarned = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AcademicCreditHoursEarned->g;
    x->AcademicCreditHoursEarned = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursEarned) */

void zx_hrxml_DegreeMeasure_PUT_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AcademicCreditHoursEarned;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AcademicCreditHoursEarned = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursEarned) */

void zx_hrxml_DegreeMeasure_ADD_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AcademicCreditHoursEarned->g;
    x->AcademicCreditHoursEarned = z;
    return;
  case -1:
    y = x->AcademicCreditHoursEarned;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursEarned; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursEarned) */

void zx_hrxml_DegreeMeasure_DEL_AcademicCreditHoursEarned(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AcademicCreditHoursEarned = (struct zx_elem_s*)x->AcademicCreditHoursEarned->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AcademicCreditHoursEarned;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AcademicCreditHoursEarned; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMeasure_NUM_ClassRank) */

int zx_hrxml_DegreeMeasure_NUM_ClassRank(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_ClassRank_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ClassRank; y; ++n, y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMeasure_GET_ClassRank) */

struct zx_hrxml_ClassRank_s* zx_hrxml_DegreeMeasure_GET_ClassRank(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_hrxml_ClassRank_s* y;
  if (!x) return 0;
  for (y = x->ClassRank; n>=0 && y; --n, y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_POP_ClassRank) */

struct zx_hrxml_ClassRank_s* zx_hrxml_DegreeMeasure_POP_ClassRank(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_ClassRank_s* y;
  if (!x) return 0;
  y = x->ClassRank;
  if (y)
    x->ClassRank = (struct zx_hrxml_ClassRank_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMeasure_PUSH_ClassRank) */

void zx_hrxml_DegreeMeasure_PUSH_ClassRank(struct zx_hrxml_DegreeMeasure_s* x, struct zx_hrxml_ClassRank_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ClassRank->gg.g;
  x->ClassRank = z;
}

/* FUNC(zx_hrxml_DegreeMeasure_REV_ClassRank) */

void zx_hrxml_DegreeMeasure_REV_ClassRank(struct zx_hrxml_DegreeMeasure_s* x)
{
  struct zx_hrxml_ClassRank_s* nxt;
  struct zx_hrxml_ClassRank_s* y;
  if (!x) return;
  y = x->ClassRank;
  if (!y) return;
  x->ClassRank = 0;
  while (y) {
    nxt = (struct zx_hrxml_ClassRank_s*)y->gg.g.n;
    y->gg.g.n = &x->ClassRank->gg.g;
    x->ClassRank = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_PUT_ClassRank) */

void zx_hrxml_DegreeMeasure_PUT_ClassRank(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_hrxml_ClassRank_s* z)
{
  struct zx_hrxml_ClassRank_s* y;
  if (!x || !z) return;
  y = x->ClassRank;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ClassRank = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeMeasure_ADD_ClassRank) */

void zx_hrxml_DegreeMeasure_ADD_ClassRank(struct zx_hrxml_DegreeMeasure_s* x, int n, struct zx_hrxml_ClassRank_s* z)
{
  struct zx_hrxml_ClassRank_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ClassRank->gg.g;
    x->ClassRank = z;
    return;
  case -1:
    y = x->ClassRank;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ClassRank; n > 1 && y; --n, y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeMeasure_DEL_ClassRank) */

void zx_hrxml_DegreeMeasure_DEL_ClassRank(struct zx_hrxml_DegreeMeasure_s* x, int n)
{
  struct zx_hrxml_ClassRank_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ClassRank = (struct zx_hrxml_ClassRank_s*)x->ClassRank->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ClassRank_s*)x->ClassRank;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ClassRank; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ClassRank_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_DegreeMeasure_GET_measureType) */
struct zx_str* zx_hrxml_DegreeMeasure_GET_measureType(struct zx_hrxml_DegreeMeasure_s* x) { return x->measureType; }
/* FUNC(zx_hrxml_DegreeMeasure_PUT_measureType) */
void zx_hrxml_DegreeMeasure_PUT_measureType(struct zx_hrxml_DegreeMeasure_s* x, struct zx_str* y) { x->measureType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMinor_NUM_ProgramId) */

int zx_hrxml_DegreeMinor_NUM_ProgramId(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_hrxml_ProgramId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProgramId; y; ++n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMinor_GET_ProgramId) */

struct zx_hrxml_ProgramId_s* zx_hrxml_DegreeMinor_GET_ProgramId(struct zx_hrxml_DegreeMinor_s* x, int n)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return 0;
  for (y = x->ProgramId; n>=0 && y; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMinor_POP_ProgramId) */

struct zx_hrxml_ProgramId_s* zx_hrxml_DegreeMinor_POP_ProgramId(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return 0;
  y = x->ProgramId;
  if (y)
    x->ProgramId = (struct zx_hrxml_ProgramId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMinor_PUSH_ProgramId) */

void zx_hrxml_DegreeMinor_PUSH_ProgramId(struct zx_hrxml_DegreeMinor_s* x, struct zx_hrxml_ProgramId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ProgramId->gg.g;
  x->ProgramId = z;
}

/* FUNC(zx_hrxml_DegreeMinor_REV_ProgramId) */

void zx_hrxml_DegreeMinor_REV_ProgramId(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_hrxml_ProgramId_s* nxt;
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return;
  y = x->ProgramId;
  if (!y) return;
  x->ProgramId = 0;
  while (y) {
    nxt = (struct zx_hrxml_ProgramId_s*)y->gg.g.n;
    y->gg.g.n = &x->ProgramId->gg.g;
    x->ProgramId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMinor_PUT_ProgramId) */

void zx_hrxml_DegreeMinor_PUT_ProgramId(struct zx_hrxml_DegreeMinor_s* x, int n, struct zx_hrxml_ProgramId_s* z)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x || !z) return;
  y = x->ProgramId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ProgramId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DegreeMinor_ADD_ProgramId) */

void zx_hrxml_DegreeMinor_ADD_ProgramId(struct zx_hrxml_DegreeMinor_s* x, int n, struct zx_hrxml_ProgramId_s* z)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ProgramId->gg.g;
    x->ProgramId = z;
    return;
  case -1:
    y = x->ProgramId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProgramId; n > 1 && y; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DegreeMinor_DEL_ProgramId) */

void zx_hrxml_DegreeMinor_DEL_ProgramId(struct zx_hrxml_DegreeMinor_s* x, int n)
{
  struct zx_hrxml_ProgramId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProgramId = (struct zx_hrxml_ProgramId_s*)x->ProgramId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ProgramId_s*)x->ProgramId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProgramId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProgramId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DegreeMinor_NUM_Name) */

int zx_hrxml_DegreeMinor_NUM_Name(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DegreeMinor_GET_Name) */

struct zx_elem_s* zx_hrxml_DegreeMinor_GET_Name(struct zx_hrxml_DegreeMinor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DegreeMinor_POP_Name) */

struct zx_elem_s* zx_hrxml_DegreeMinor_POP_Name(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DegreeMinor_PUSH_Name) */

void zx_hrxml_DegreeMinor_PUSH_Name(struct zx_hrxml_DegreeMinor_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_DegreeMinor_REV_Name) */

void zx_hrxml_DegreeMinor_REV_Name(struct zx_hrxml_DegreeMinor_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DegreeMinor_PUT_Name) */

void zx_hrxml_DegreeMinor_PUT_Name(struct zx_hrxml_DegreeMinor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DegreeMinor_ADD_Name) */

void zx_hrxml_DegreeMinor_ADD_Name(struct zx_hrxml_DegreeMinor_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DegreeMinor_DEL_Name) */

void zx_hrxml_DegreeMinor_DEL_Name(struct zx_hrxml_DegreeMinor_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_DegreeName_GET_academicHonors) */
struct zx_str* zx_hrxml_DegreeName_GET_academicHonors(struct zx_hrxml_DegreeName_s* x) { return x->academicHonors; }
/* FUNC(zx_hrxml_DegreeName_PUT_academicHonors) */
void zx_hrxml_DegreeName_PUT_academicHonors(struct zx_hrxml_DegreeName_s* x, struct zx_str* y) { x->academicHonors = y; }
/* FUNC(zx_hrxml_DegreeName_GET_honorsProgram) */
struct zx_str* zx_hrxml_DegreeName_GET_honorsProgram(struct zx_hrxml_DegreeName_s* x) { return x->honorsProgram; }
/* FUNC(zx_hrxml_DegreeName_PUT_honorsProgram) */
void zx_hrxml_DegreeName_PUT_honorsProgram(struct zx_hrxml_DegreeName_s* x, struct zx_str* y) { x->honorsProgram = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DeliveryAddress_NUM_AddressLine) */

int zx_hrxml_DeliveryAddress_NUM_AddressLine(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AddressLine; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DeliveryAddress_GET_AddressLine) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_GET_AddressLine(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AddressLine; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_POP_AddressLine) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_POP_AddressLine(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AddressLine;
  if (y)
    x->AddressLine = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_PUSH_AddressLine) */

void zx_hrxml_DeliveryAddress_PUSH_AddressLine(struct zx_hrxml_DeliveryAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AddressLine->g;
  x->AddressLine = z;
}

/* FUNC(zx_hrxml_DeliveryAddress_REV_AddressLine) */

void zx_hrxml_DeliveryAddress_REV_AddressLine(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AddressLine;
  if (!y) return;
  x->AddressLine = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AddressLine->g;
    x->AddressLine = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_PUT_AddressLine) */

void zx_hrxml_DeliveryAddress_PUT_AddressLine(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AddressLine;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AddressLine = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_ADD_AddressLine) */

void zx_hrxml_DeliveryAddress_ADD_AddressLine(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AddressLine->g;
    x->AddressLine = z;
    return;
  case -1:
    y = x->AddressLine;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AddressLine; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DeliveryAddress_DEL_AddressLine) */

void zx_hrxml_DeliveryAddress_DEL_AddressLine(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AddressLine = (struct zx_elem_s*)x->AddressLine->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AddressLine;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AddressLine; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DeliveryAddress_NUM_StreetName) */

int zx_hrxml_DeliveryAddress_NUM_StreetName(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StreetName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DeliveryAddress_GET_StreetName) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_GET_StreetName(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StreetName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_POP_StreetName) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_POP_StreetName(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StreetName;
  if (y)
    x->StreetName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_PUSH_StreetName) */

void zx_hrxml_DeliveryAddress_PUSH_StreetName(struct zx_hrxml_DeliveryAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StreetName->g;
  x->StreetName = z;
}

/* FUNC(zx_hrxml_DeliveryAddress_REV_StreetName) */

void zx_hrxml_DeliveryAddress_REV_StreetName(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StreetName;
  if (!y) return;
  x->StreetName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StreetName->g;
    x->StreetName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_PUT_StreetName) */

void zx_hrxml_DeliveryAddress_PUT_StreetName(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StreetName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StreetName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_ADD_StreetName) */

void zx_hrxml_DeliveryAddress_ADD_StreetName(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StreetName->g;
    x->StreetName = z;
    return;
  case -1:
    y = x->StreetName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StreetName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DeliveryAddress_DEL_StreetName) */

void zx_hrxml_DeliveryAddress_DEL_StreetName(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StreetName = (struct zx_elem_s*)x->StreetName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StreetName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StreetName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DeliveryAddress_NUM_BuildingNumber) */

int zx_hrxml_DeliveryAddress_NUM_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BuildingNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DeliveryAddress_GET_BuildingNumber) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_GET_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->BuildingNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_POP_BuildingNumber) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_POP_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->BuildingNumber;
  if (y)
    x->BuildingNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_PUSH_BuildingNumber) */

void zx_hrxml_DeliveryAddress_PUSH_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->BuildingNumber->g;
  x->BuildingNumber = z;
}

/* FUNC(zx_hrxml_DeliveryAddress_REV_BuildingNumber) */

void zx_hrxml_DeliveryAddress_REV_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->BuildingNumber;
  if (!y) return;
  x->BuildingNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->BuildingNumber->g;
    x->BuildingNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_PUT_BuildingNumber) */

void zx_hrxml_DeliveryAddress_PUT_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->BuildingNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->BuildingNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_ADD_BuildingNumber) */

void zx_hrxml_DeliveryAddress_ADD_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->BuildingNumber->g;
    x->BuildingNumber = z;
    return;
  case -1:
    y = x->BuildingNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BuildingNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DeliveryAddress_DEL_BuildingNumber) */

void zx_hrxml_DeliveryAddress_DEL_BuildingNumber(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BuildingNumber = (struct zx_elem_s*)x->BuildingNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->BuildingNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BuildingNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DeliveryAddress_NUM_Unit) */

int zx_hrxml_DeliveryAddress_NUM_Unit(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Unit; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DeliveryAddress_GET_Unit) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_GET_Unit(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Unit; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_POP_Unit) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_POP_Unit(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Unit;
  if (y)
    x->Unit = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_PUSH_Unit) */

void zx_hrxml_DeliveryAddress_PUSH_Unit(struct zx_hrxml_DeliveryAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Unit->g;
  x->Unit = z;
}

/* FUNC(zx_hrxml_DeliveryAddress_REV_Unit) */

void zx_hrxml_DeliveryAddress_REV_Unit(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Unit;
  if (!y) return;
  x->Unit = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Unit->g;
    x->Unit = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_PUT_Unit) */

void zx_hrxml_DeliveryAddress_PUT_Unit(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Unit;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Unit = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_ADD_Unit) */

void zx_hrxml_DeliveryAddress_ADD_Unit(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Unit->g;
    x->Unit = z;
    return;
  case -1:
    y = x->Unit;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Unit; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DeliveryAddress_DEL_Unit) */

void zx_hrxml_DeliveryAddress_DEL_Unit(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Unit = (struct zx_elem_s*)x->Unit->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Unit;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Unit; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DeliveryAddress_NUM_PostOfficeBox) */

int zx_hrxml_DeliveryAddress_NUM_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostOfficeBox; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DeliveryAddress_GET_PostOfficeBox) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_GET_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PostOfficeBox; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_POP_PostOfficeBox) */

struct zx_elem_s* zx_hrxml_DeliveryAddress_POP_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PostOfficeBox;
  if (y)
    x->PostOfficeBox = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DeliveryAddress_PUSH_PostOfficeBox) */

void zx_hrxml_DeliveryAddress_PUSH_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PostOfficeBox->g;
  x->PostOfficeBox = z;
}

/* FUNC(zx_hrxml_DeliveryAddress_REV_PostOfficeBox) */

void zx_hrxml_DeliveryAddress_REV_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PostOfficeBox;
  if (!y) return;
  x->PostOfficeBox = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PostOfficeBox->g;
    x->PostOfficeBox = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_PUT_PostOfficeBox) */

void zx_hrxml_DeliveryAddress_PUT_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PostOfficeBox;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PostOfficeBox = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DeliveryAddress_ADD_PostOfficeBox) */

void zx_hrxml_DeliveryAddress_ADD_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PostOfficeBox->g;
    x->PostOfficeBox = z;
    return;
  case -1:
    y = x->PostOfficeBox;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostOfficeBox; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DeliveryAddress_DEL_PostOfficeBox) */

void zx_hrxml_DeliveryAddress_DEL_PostOfficeBox(struct zx_hrxml_DeliveryAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostOfficeBox = (struct zx_elem_s*)x->PostOfficeBox->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PostOfficeBox;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostOfficeBox; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_Race) */

int zx_hrxml_DemographicDescriptors_NUM_Race(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Race; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_Race) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_Race(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Race; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_Race) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_Race(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Race;
  if (y)
    x->Race = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_Race) */

void zx_hrxml_DemographicDescriptors_PUSH_Race(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Race->g;
  x->Race = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_Race) */

void zx_hrxml_DemographicDescriptors_REV_Race(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Race;
  if (!y) return;
  x->Race = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Race->g;
    x->Race = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_Race) */

void zx_hrxml_DemographicDescriptors_PUT_Race(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Race;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Race = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_Race) */

void zx_hrxml_DemographicDescriptors_ADD_Race(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Race->g;
    x->Race = z;
    return;
  case -1:
    y = x->Race;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Race; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_Race) */

void zx_hrxml_DemographicDescriptors_DEL_Race(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Race = (struct zx_elem_s*)x->Race->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Race;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Race; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_Ethnicity) */

int zx_hrxml_DemographicDescriptors_NUM_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Ethnicity; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_Ethnicity) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Ethnicity; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_Ethnicity) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Ethnicity;
  if (y)
    x->Ethnicity = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_Ethnicity) */

void zx_hrxml_DemographicDescriptors_PUSH_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Ethnicity->g;
  x->Ethnicity = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_Ethnicity) */

void zx_hrxml_DemographicDescriptors_REV_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Ethnicity;
  if (!y) return;
  x->Ethnicity = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Ethnicity->g;
    x->Ethnicity = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_Ethnicity) */

void zx_hrxml_DemographicDescriptors_PUT_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Ethnicity;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Ethnicity = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_Ethnicity) */

void zx_hrxml_DemographicDescriptors_ADD_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Ethnicity->g;
    x->Ethnicity = z;
    return;
  case -1:
    y = x->Ethnicity;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Ethnicity; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_Ethnicity) */

void zx_hrxml_DemographicDescriptors_DEL_Ethnicity(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Ethnicity = (struct zx_elem_s*)x->Ethnicity->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Ethnicity;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Ethnicity; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_Nationality) */

int zx_hrxml_DemographicDescriptors_NUM_Nationality(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Nationality; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_Nationality) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_Nationality(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Nationality; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_Nationality) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_Nationality(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Nationality;
  if (y)
    x->Nationality = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_Nationality) */

void zx_hrxml_DemographicDescriptors_PUSH_Nationality(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Nationality->g;
  x->Nationality = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_Nationality) */

void zx_hrxml_DemographicDescriptors_REV_Nationality(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Nationality;
  if (!y) return;
  x->Nationality = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Nationality->g;
    x->Nationality = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_Nationality) */

void zx_hrxml_DemographicDescriptors_PUT_Nationality(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Nationality;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Nationality = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_Nationality) */

void zx_hrxml_DemographicDescriptors_ADD_Nationality(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Nationality->g;
    x->Nationality = z;
    return;
  case -1:
    y = x->Nationality;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Nationality; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_Nationality) */

void zx_hrxml_DemographicDescriptors_DEL_Nationality(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Nationality = (struct zx_elem_s*)x->Nationality->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Nationality;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Nationality; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_PrimaryLanguage) */

int zx_hrxml_DemographicDescriptors_NUM_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PrimaryLanguage; y; ++n, y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_PrimaryLanguage) */

struct zx_hrxml_PrimaryLanguage_s* zx_hrxml_DemographicDescriptors_GET_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x) return 0;
  for (y = x->PrimaryLanguage; n>=0 && y; --n, y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_PrimaryLanguage) */

struct zx_hrxml_PrimaryLanguage_s* zx_hrxml_DemographicDescriptors_POP_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x) return 0;
  y = x->PrimaryLanguage;
  if (y)
    x->PrimaryLanguage = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_PrimaryLanguage) */

void zx_hrxml_DemographicDescriptors_PUSH_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_hrxml_PrimaryLanguage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PrimaryLanguage->gg.g;
  x->PrimaryLanguage = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_PrimaryLanguage) */

void zx_hrxml_DemographicDescriptors_REV_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_PrimaryLanguage_s* nxt;
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x) return;
  y = x->PrimaryLanguage;
  if (!y) return;
  x->PrimaryLanguage = 0;
  while (y) {
    nxt = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n;
    y->gg.g.n = &x->PrimaryLanguage->gg.g;
    x->PrimaryLanguage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_PrimaryLanguage) */

void zx_hrxml_DemographicDescriptors_PUT_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_PrimaryLanguage_s* z)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x || !z) return;
  y = x->PrimaryLanguage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PrimaryLanguage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_PrimaryLanguage) */

void zx_hrxml_DemographicDescriptors_ADD_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_PrimaryLanguage_s* z)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PrimaryLanguage->gg.g;
    x->PrimaryLanguage = z;
    return;
  case -1:
    y = x->PrimaryLanguage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PrimaryLanguage; n > 1 && y; --n, y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_PrimaryLanguage) */

void zx_hrxml_DemographicDescriptors_DEL_PrimaryLanguage(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_PrimaryLanguage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PrimaryLanguage = (struct zx_hrxml_PrimaryLanguage_s*)x->PrimaryLanguage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PrimaryLanguage_s*)x->PrimaryLanguage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PrimaryLanguage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PrimaryLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_BirthPlace) */

int zx_hrxml_DemographicDescriptors_NUM_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BirthPlace; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_BirthPlace) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->BirthPlace; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_BirthPlace) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->BirthPlace;
  if (y)
    x->BirthPlace = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_BirthPlace) */

void zx_hrxml_DemographicDescriptors_PUSH_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->BirthPlace->g;
  x->BirthPlace = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_BirthPlace) */

void zx_hrxml_DemographicDescriptors_REV_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->BirthPlace;
  if (!y) return;
  x->BirthPlace = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->BirthPlace->g;
    x->BirthPlace = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_BirthPlace) */

void zx_hrxml_DemographicDescriptors_PUT_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->BirthPlace;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->BirthPlace = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_BirthPlace) */

void zx_hrxml_DemographicDescriptors_ADD_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->BirthPlace->g;
    x->BirthPlace = z;
    return;
  case -1:
    y = x->BirthPlace;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BirthPlace; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_BirthPlace) */

void zx_hrxml_DemographicDescriptors_DEL_BirthPlace(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BirthPlace = (struct zx_elem_s*)x->BirthPlace->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->BirthPlace;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->BirthPlace; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_Religion) */

int zx_hrxml_DemographicDescriptors_NUM_Religion(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Religion; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_Religion) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_Religion(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Religion; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_Religion) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_Religion(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Religion;
  if (y)
    x->Religion = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_Religion) */

void zx_hrxml_DemographicDescriptors_PUSH_Religion(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Religion->g;
  x->Religion = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_Religion) */

void zx_hrxml_DemographicDescriptors_REV_Religion(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Religion;
  if (!y) return;
  x->Religion = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Religion->g;
    x->Religion = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_Religion) */

void zx_hrxml_DemographicDescriptors_PUT_Religion(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Religion;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Religion = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_Religion) */

void zx_hrxml_DemographicDescriptors_ADD_Religion(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Religion->g;
    x->Religion = z;
    return;
  case -1:
    y = x->Religion;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Religion; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_Religion) */

void zx_hrxml_DemographicDescriptors_DEL_Religion(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Religion = (struct zx_elem_s*)x->Religion->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Religion;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Religion; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_MaritalStatus) */

int zx_hrxml_DemographicDescriptors_NUM_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MaritalStatus; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_MaritalStatus) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_GET_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MaritalStatus; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_MaritalStatus) */

struct zx_elem_s* zx_hrxml_DemographicDescriptors_POP_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MaritalStatus;
  if (y)
    x->MaritalStatus = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_MaritalStatus) */

void zx_hrxml_DemographicDescriptors_PUSH_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MaritalStatus->g;
  x->MaritalStatus = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_MaritalStatus) */

void zx_hrxml_DemographicDescriptors_REV_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MaritalStatus;
  if (!y) return;
  x->MaritalStatus = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MaritalStatus->g;
    x->MaritalStatus = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_MaritalStatus) */

void zx_hrxml_DemographicDescriptors_PUT_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MaritalStatus;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MaritalStatus = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_MaritalStatus) */

void zx_hrxml_DemographicDescriptors_ADD_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MaritalStatus->g;
    x->MaritalStatus = z;
    return;
  case -1:
    y = x->MaritalStatus;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MaritalStatus; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_MaritalStatus) */

void zx_hrxml_DemographicDescriptors_DEL_MaritalStatus(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MaritalStatus = (struct zx_elem_s*)x->MaritalStatus->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MaritalStatus;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MaritalStatus; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_ChildrenInfo) */

int zx_hrxml_DemographicDescriptors_NUM_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ChildrenInfo; y; ++n, y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_ChildrenInfo) */

struct zx_hrxml_ChildrenInfo_s* zx_hrxml_DemographicDescriptors_GET_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x) return 0;
  for (y = x->ChildrenInfo; n>=0 && y; --n, y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_ChildrenInfo) */

struct zx_hrxml_ChildrenInfo_s* zx_hrxml_DemographicDescriptors_POP_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x) return 0;
  y = x->ChildrenInfo;
  if (y)
    x->ChildrenInfo = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_ChildrenInfo) */

void zx_hrxml_DemographicDescriptors_PUSH_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_hrxml_ChildrenInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ChildrenInfo->gg.g;
  x->ChildrenInfo = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_ChildrenInfo) */

void zx_hrxml_DemographicDescriptors_REV_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_ChildrenInfo_s* nxt;
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x) return;
  y = x->ChildrenInfo;
  if (!y) return;
  x->ChildrenInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->ChildrenInfo->gg.g;
    x->ChildrenInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_ChildrenInfo) */

void zx_hrxml_DemographicDescriptors_PUT_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_ChildrenInfo_s* z)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x || !z) return;
  y = x->ChildrenInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ChildrenInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_ChildrenInfo) */

void zx_hrxml_DemographicDescriptors_ADD_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_ChildrenInfo_s* z)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ChildrenInfo->gg.g;
    x->ChildrenInfo = z;
    return;
  case -1:
    y = x->ChildrenInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ChildrenInfo; n > 1 && y; --n, y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_ChildrenInfo) */

void zx_hrxml_DemographicDescriptors_DEL_ChildrenInfo(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_ChildrenInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ChildrenInfo = (struct zx_hrxml_ChildrenInfo_s*)x->ChildrenInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ChildrenInfo_s*)x->ChildrenInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ChildrenInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ChildrenInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DemographicDescriptors_NUM_UserArea) */

int zx_hrxml_DemographicDescriptors_NUM_UserArea(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DemographicDescriptors_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_DemographicDescriptors_GET_UserArea(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_DemographicDescriptors_POP_UserArea(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUSH_UserArea) */

void zx_hrxml_DemographicDescriptors_PUSH_UserArea(struct zx_hrxml_DemographicDescriptors_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_DemographicDescriptors_REV_UserArea) */

void zx_hrxml_DemographicDescriptors_REV_UserArea(struct zx_hrxml_DemographicDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_PUT_UserArea) */

void zx_hrxml_DemographicDescriptors_PUT_UserArea(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DemographicDescriptors_ADD_UserArea) */

void zx_hrxml_DemographicDescriptors_ADD_UserArea(struct zx_hrxml_DemographicDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DemographicDescriptors_DEL_UserArea) */

void zx_hrxml_DemographicDescriptors_DEL_UserArea(struct zx_hrxml_DemographicDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_Description_GET_lang) */
struct zx_str* zx_hrxml_Description_GET_lang(struct zx_hrxml_Description_s* x) { return x->lang; }
/* FUNC(zx_hrxml_Description_PUT_lang) */
void zx_hrxml_Description_PUT_lang(struct zx_hrxml_Description_s* x, struct zx_str* y) { x->lang = y; }





/* FUNC(zx_hrxml_Details_GET_type) */
struct zx_str* zx_hrxml_Details_GET_type(struct zx_hrxml_Details_s* x) { return x->type; }
/* FUNC(zx_hrxml_Details_PUT_type) */
void zx_hrxml_Details_PUT_type(struct zx_hrxml_Details_s* x, struct zx_str* y) { x->type = y; }
/* FUNC(zx_hrxml_Details_GET_lang) */
struct zx_str* zx_hrxml_Details_GET_lang(struct zx_hrxml_Details_s* x) { return x->lang; }
/* FUNC(zx_hrxml_Details_PUT_lang) */
void zx_hrxml_Details_PUT_lang(struct zx_hrxml_Details_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DisabilityInfo_NUM_LevelOfDisability) */

int zx_hrxml_DisabilityInfo_NUM_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LevelOfDisability; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DisabilityInfo_GET_LevelOfDisability) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_GET_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->LevelOfDisability; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_POP_LevelOfDisability) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_POP_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->LevelOfDisability;
  if (y)
    x->LevelOfDisability = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_PUSH_LevelOfDisability) */

void zx_hrxml_DisabilityInfo_PUSH_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->LevelOfDisability->g;
  x->LevelOfDisability = z;
}

/* FUNC(zx_hrxml_DisabilityInfo_REV_LevelOfDisability) */

void zx_hrxml_DisabilityInfo_REV_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->LevelOfDisability;
  if (!y) return;
  x->LevelOfDisability = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->LevelOfDisability->g;
    x->LevelOfDisability = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_PUT_LevelOfDisability) */

void zx_hrxml_DisabilityInfo_PUT_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->LevelOfDisability;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->LevelOfDisability = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_ADD_LevelOfDisability) */

void zx_hrxml_DisabilityInfo_ADD_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->LevelOfDisability->g;
    x->LevelOfDisability = z;
    return;
  case -1:
    y = x->LevelOfDisability;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LevelOfDisability; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DisabilityInfo_DEL_LevelOfDisability) */

void zx_hrxml_DisabilityInfo_DEL_LevelOfDisability(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LevelOfDisability = (struct zx_elem_s*)x->LevelOfDisability->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->LevelOfDisability;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LevelOfDisability; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DisabilityInfo_NUM_Percentage) */

int zx_hrxml_DisabilityInfo_NUM_Percentage(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Percentage; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DisabilityInfo_GET_Percentage) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_GET_Percentage(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Percentage; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_POP_Percentage) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_POP_Percentage(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Percentage;
  if (y)
    x->Percentage = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_PUSH_Percentage) */

void zx_hrxml_DisabilityInfo_PUSH_Percentage(struct zx_hrxml_DisabilityInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Percentage->g;
  x->Percentage = z;
}

/* FUNC(zx_hrxml_DisabilityInfo_REV_Percentage) */

void zx_hrxml_DisabilityInfo_REV_Percentage(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Percentage;
  if (!y) return;
  x->Percentage = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Percentage->g;
    x->Percentage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_PUT_Percentage) */

void zx_hrxml_DisabilityInfo_PUT_Percentage(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Percentage;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Percentage = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_ADD_Percentage) */

void zx_hrxml_DisabilityInfo_ADD_Percentage(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Percentage->g;
    x->Percentage = z;
    return;
  case -1:
    y = x->Percentage;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Percentage; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DisabilityInfo_DEL_Percentage) */

void zx_hrxml_DisabilityInfo_DEL_Percentage(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Percentage = (struct zx_elem_s*)x->Percentage->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Percentage;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Percentage; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DisabilityInfo_NUM_Type) */

int zx_hrxml_DisabilityInfo_NUM_Type(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Type; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DisabilityInfo_GET_Type) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_GET_Type(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Type; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_POP_Type) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_POP_Type(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Type;
  if (y)
    x->Type = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_PUSH_Type) */

void zx_hrxml_DisabilityInfo_PUSH_Type(struct zx_hrxml_DisabilityInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Type->g;
  x->Type = z;
}

/* FUNC(zx_hrxml_DisabilityInfo_REV_Type) */

void zx_hrxml_DisabilityInfo_REV_Type(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Type;
  if (!y) return;
  x->Type = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Type->g;
    x->Type = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_PUT_Type) */

void zx_hrxml_DisabilityInfo_PUT_Type(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Type;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Type = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_ADD_Type) */

void zx_hrxml_DisabilityInfo_ADD_Type(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Type->g;
    x->Type = z;
    return;
  case -1:
    y = x->Type;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Type; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DisabilityInfo_DEL_Type) */

void zx_hrxml_DisabilityInfo_DEL_Type(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Type = (struct zx_elem_s*)x->Type->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Type;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Type; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DisabilityInfo_NUM_AccommodationsNeeded) */

int zx_hrxml_DisabilityInfo_NUM_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AccommodationsNeeded; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DisabilityInfo_GET_AccommodationsNeeded) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_GET_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AccommodationsNeeded; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_POP_AccommodationsNeeded) */

struct zx_elem_s* zx_hrxml_DisabilityInfo_POP_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AccommodationsNeeded;
  if (y)
    x->AccommodationsNeeded = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_DisabilityInfo_PUSH_AccommodationsNeeded) */

void zx_hrxml_DisabilityInfo_PUSH_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AccommodationsNeeded->g;
  x->AccommodationsNeeded = z;
}

/* FUNC(zx_hrxml_DisabilityInfo_REV_AccommodationsNeeded) */

void zx_hrxml_DisabilityInfo_REV_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AccommodationsNeeded;
  if (!y) return;
  x->AccommodationsNeeded = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AccommodationsNeeded->g;
    x->AccommodationsNeeded = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_PUT_AccommodationsNeeded) */

void zx_hrxml_DisabilityInfo_PUT_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AccommodationsNeeded;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AccommodationsNeeded = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_DisabilityInfo_ADD_AccommodationsNeeded) */

void zx_hrxml_DisabilityInfo_ADD_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AccommodationsNeeded->g;
    x->AccommodationsNeeded = z;
    return;
  case -1:
    y = x->AccommodationsNeeded;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AccommodationsNeeded; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_DisabilityInfo_DEL_AccommodationsNeeded) */

void zx_hrxml_DisabilityInfo_DEL_AccommodationsNeeded(struct zx_hrxml_DisabilityInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AccommodationsNeeded = (struct zx_elem_s*)x->AccommodationsNeeded->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AccommodationsNeeded;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AccommodationsNeeded; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_DistanceMax_GET_unitOfMeasure) */
struct zx_str* zx_hrxml_DistanceMax_GET_unitOfMeasure(struct zx_hrxml_DistanceMax_s* x) { return x->unitOfMeasure; }
/* FUNC(zx_hrxml_DistanceMax_PUT_unitOfMeasure) */
void zx_hrxml_DistanceMax_PUT_unitOfMeasure(struct zx_hrxml_DistanceMax_s* x, struct zx_str* y) { x->unitOfMeasure = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_DistributeTo_NUM_ContactMethod) */

int zx_hrxml_DistributeTo_NUM_ContactMethod(struct zx_hrxml_DistributeTo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_DistributeTo_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_DistributeTo_GET_ContactMethod(struct zx_hrxml_DistributeTo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_DistributeTo_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_DistributeTo_POP_ContactMethod(struct zx_hrxml_DistributeTo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_DistributeTo_PUSH_ContactMethod) */

void zx_hrxml_DistributeTo_PUSH_ContactMethod(struct zx_hrxml_DistributeTo_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_DistributeTo_REV_ContactMethod) */

void zx_hrxml_DistributeTo_REV_ContactMethod(struct zx_hrxml_DistributeTo_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_DistributeTo_PUT_ContactMethod) */

void zx_hrxml_DistributeTo_PUT_ContactMethod(struct zx_hrxml_DistributeTo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_DistributeTo_ADD_ContactMethod) */

void zx_hrxml_DistributeTo_ADD_ContactMethod(struct zx_hrxml_DistributeTo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_DistributeTo_DEL_ContactMethod) */

void zx_hrxml_DistributeTo_DEL_ContactMethod(struct zx_hrxml_DistributeTo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_DoingBusinessAs_GET_lang) */
struct zx_str* zx_hrxml_DoingBusinessAs_GET_lang(struct zx_hrxml_DoingBusinessAs_s* x) { return x->lang; }
/* FUNC(zx_hrxml_DoingBusinessAs_PUT_lang) */
void zx_hrxml_DoingBusinessAs_PUT_lang(struct zx_hrxml_DoingBusinessAs_s* x, struct zx_str* y) { x->lang = y; }





/* FUNC(zx_hrxml_DressCode_GET_suppliedByOrganization) */
struct zx_str* zx_hrxml_DressCode_GET_suppliedByOrganization(struct zx_hrxml_DressCode_s* x) { return x->suppliedByOrganization; }
/* FUNC(zx_hrxml_DressCode_PUT_suppliedByOrganization) */
void zx_hrxml_DressCode_PUT_suppliedByOrganization(struct zx_hrxml_DressCode_s* x, struct zx_str* y) { x->suppliedByOrganization = y; }





/* FUNC(zx_hrxml_DunsNumber_GET_dunsNumberType) */
struct zx_str* zx_hrxml_DunsNumber_GET_dunsNumberType(struct zx_hrxml_DunsNumber_s* x) { return x->dunsNumberType; }
/* FUNC(zx_hrxml_DunsNumber_PUT_dunsNumberType) */
void zx_hrxml_DunsNumber_PUT_dunsNumberType(struct zx_hrxml_DunsNumber_s* x, struct zx_str* y) { x->dunsNumberType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EEOCJobCategory_NUM_StandardValue) */

int zx_hrxml_EEOCJobCategory_NUM_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StandardValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EEOCJobCategory_GET_StandardValue) */

struct zx_elem_s* zx_hrxml_EEOCJobCategory_GET_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StandardValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EEOCJobCategory_POP_StandardValue) */

struct zx_elem_s* zx_hrxml_EEOCJobCategory_POP_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StandardValue;
  if (y)
    x->StandardValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EEOCJobCategory_PUSH_StandardValue) */

void zx_hrxml_EEOCJobCategory_PUSH_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StandardValue->g;
  x->StandardValue = z;
}

/* FUNC(zx_hrxml_EEOCJobCategory_REV_StandardValue) */

void zx_hrxml_EEOCJobCategory_REV_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StandardValue;
  if (!y) return;
  x->StandardValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StandardValue->g;
    x->StandardValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EEOCJobCategory_PUT_StandardValue) */

void zx_hrxml_EEOCJobCategory_PUT_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StandardValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StandardValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EEOCJobCategory_ADD_StandardValue) */

void zx_hrxml_EEOCJobCategory_ADD_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StandardValue->g;
    x->StandardValue = z;
    return;
  case -1:
    y = x->StandardValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StandardValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EEOCJobCategory_DEL_StandardValue) */

void zx_hrxml_EEOCJobCategory_DEL_StandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StandardValue = (struct zx_elem_s*)x->StandardValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StandardValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StandardValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EEOCJobCategory_NUM_NonStandardValue) */

int zx_hrxml_EEOCJobCategory_NUM_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NonStandardValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EEOCJobCategory_GET_NonStandardValue) */

struct zx_elem_s* zx_hrxml_EEOCJobCategory_GET_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->NonStandardValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EEOCJobCategory_POP_NonStandardValue) */

struct zx_elem_s* zx_hrxml_EEOCJobCategory_POP_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->NonStandardValue;
  if (y)
    x->NonStandardValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EEOCJobCategory_PUSH_NonStandardValue) */

void zx_hrxml_EEOCJobCategory_PUSH_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->NonStandardValue->g;
  x->NonStandardValue = z;
}

/* FUNC(zx_hrxml_EEOCJobCategory_REV_NonStandardValue) */

void zx_hrxml_EEOCJobCategory_REV_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->NonStandardValue;
  if (!y) return;
  x->NonStandardValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->NonStandardValue->g;
    x->NonStandardValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EEOCJobCategory_PUT_NonStandardValue) */

void zx_hrxml_EEOCJobCategory_PUT_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->NonStandardValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->NonStandardValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EEOCJobCategory_ADD_NonStandardValue) */

void zx_hrxml_EEOCJobCategory_ADD_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->NonStandardValue->g;
    x->NonStandardValue = z;
    return;
  case -1:
    y = x->NonStandardValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NonStandardValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EEOCJobCategory_DEL_NonStandardValue) */

void zx_hrxml_EEOCJobCategory_DEL_NonStandardValue(struct zx_hrxml_EEOCJobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NonStandardValue = (struct zx_elem_s*)x->NonStandardValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->NonStandardValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NonStandardValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationHistory_NUM_SchoolOrInstitution) */

int zx_hrxml_EducationHistory_NUM_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SchoolOrInstitution; y; ++n, y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationHistory_GET_SchoolOrInstitution) */

struct zx_hrxml_SchoolOrInstitution_s* zx_hrxml_EducationHistory_GET_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x, int n)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x) return 0;
  for (y = x->SchoolOrInstitution; n>=0 && y; --n, y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationHistory_POP_SchoolOrInstitution) */

struct zx_hrxml_SchoolOrInstitution_s* zx_hrxml_EducationHistory_POP_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x) return 0;
  y = x->SchoolOrInstitution;
  if (y)
    x->SchoolOrInstitution = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationHistory_PUSH_SchoolOrInstitution) */

void zx_hrxml_EducationHistory_PUSH_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x, struct zx_hrxml_SchoolOrInstitution_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SchoolOrInstitution->gg.g;
  x->SchoolOrInstitution = z;
}

/* FUNC(zx_hrxml_EducationHistory_REV_SchoolOrInstitution) */

void zx_hrxml_EducationHistory_REV_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x)
{
  struct zx_hrxml_SchoolOrInstitution_s* nxt;
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x) return;
  y = x->SchoolOrInstitution;
  if (!y) return;
  x->SchoolOrInstitution = 0;
  while (y) {
    nxt = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n;
    y->gg.g.n = &x->SchoolOrInstitution->gg.g;
    x->SchoolOrInstitution = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationHistory_PUT_SchoolOrInstitution) */

void zx_hrxml_EducationHistory_PUT_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x, int n, struct zx_hrxml_SchoolOrInstitution_s* z)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x || !z) return;
  y = x->SchoolOrInstitution;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SchoolOrInstitution = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EducationHistory_ADD_SchoolOrInstitution) */

void zx_hrxml_EducationHistory_ADD_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x, int n, struct zx_hrxml_SchoolOrInstitution_s* z)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SchoolOrInstitution->gg.g;
    x->SchoolOrInstitution = z;
    return;
  case -1:
    y = x->SchoolOrInstitution;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SchoolOrInstitution; n > 1 && y; --n, y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EducationHistory_DEL_SchoolOrInstitution) */

void zx_hrxml_EducationHistory_DEL_SchoolOrInstitution(struct zx_hrxml_EducationHistory_s* x, int n)
{
  struct zx_hrxml_SchoolOrInstitution_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SchoolOrInstitution = (struct zx_hrxml_SchoolOrInstitution_s*)x->SchoolOrInstitution->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SchoolOrInstitution_s*)x->SchoolOrInstitution;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SchoolOrInstitution; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SchoolOrInstitution_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_MeasureSystem) */

int zx_hrxml_EducationalMeasure_NUM_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MeasureSystem; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_MeasureSystem) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_GET_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MeasureSystem; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_MeasureSystem) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_POP_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MeasureSystem;
  if (y)
    x->MeasureSystem = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_MeasureSystem) */

void zx_hrxml_EducationalMeasure_PUSH_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MeasureSystem->g;
  x->MeasureSystem = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_MeasureSystem) */

void zx_hrxml_EducationalMeasure_REV_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MeasureSystem;
  if (!y) return;
  x->MeasureSystem = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MeasureSystem->g;
    x->MeasureSystem = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_MeasureSystem) */

void zx_hrxml_EducationalMeasure_PUT_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MeasureSystem;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MeasureSystem = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_MeasureSystem) */

void zx_hrxml_EducationalMeasure_ADD_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MeasureSystem->g;
    x->MeasureSystem = z;
    return;
  case -1:
    y = x->MeasureSystem;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureSystem; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_MeasureSystem) */

void zx_hrxml_EducationalMeasure_DEL_MeasureSystem(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MeasureSystem = (struct zx_elem_s*)x->MeasureSystem->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MeasureSystem;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureSystem; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_MeasureValue) */

int zx_hrxml_EducationalMeasure_NUM_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MeasureValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_MeasureValue) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_GET_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MeasureValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_MeasureValue) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_POP_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MeasureValue;
  if (y)
    x->MeasureValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_MeasureValue) */

void zx_hrxml_EducationalMeasure_PUSH_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MeasureValue->g;
  x->MeasureValue = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_MeasureValue) */

void zx_hrxml_EducationalMeasure_REV_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MeasureValue;
  if (!y) return;
  x->MeasureValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MeasureValue->g;
    x->MeasureValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_MeasureValue) */

void zx_hrxml_EducationalMeasure_PUT_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MeasureValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MeasureValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_MeasureValue) */

void zx_hrxml_EducationalMeasure_ADD_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MeasureValue->g;
    x->MeasureValue = z;
    return;
  case -1:
    y = x->MeasureValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_MeasureValue) */

void zx_hrxml_EducationalMeasure_DEL_MeasureValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MeasureValue = (struct zx_elem_s*)x->MeasureValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MeasureValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_LowestPossibleValue) */

int zx_hrxml_EducationalMeasure_NUM_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LowestPossibleValue; y; ++n, y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_LowestPossibleValue) */

struct zx_hrxml_LowestPossibleValue_s* zx_hrxml_EducationalMeasure_GET_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x) return 0;
  for (y = x->LowestPossibleValue; n>=0 && y; --n, y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_LowestPossibleValue) */

struct zx_hrxml_LowestPossibleValue_s* zx_hrxml_EducationalMeasure_POP_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x) return 0;
  y = x->LowestPossibleValue;
  if (y)
    x->LowestPossibleValue = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_LowestPossibleValue) */

void zx_hrxml_EducationalMeasure_PUSH_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, struct zx_hrxml_LowestPossibleValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LowestPossibleValue->gg.g;
  x->LowestPossibleValue = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_LowestPossibleValue) */

void zx_hrxml_EducationalMeasure_REV_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_LowestPossibleValue_s* nxt;
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x) return;
  y = x->LowestPossibleValue;
  if (!y) return;
  x->LowestPossibleValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n;
    y->gg.g.n = &x->LowestPossibleValue->gg.g;
    x->LowestPossibleValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_LowestPossibleValue) */

void zx_hrxml_EducationalMeasure_PUT_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_hrxml_LowestPossibleValue_s* z)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x || !z) return;
  y = x->LowestPossibleValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LowestPossibleValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_LowestPossibleValue) */

void zx_hrxml_EducationalMeasure_ADD_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_hrxml_LowestPossibleValue_s* z)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LowestPossibleValue->gg.g;
    x->LowestPossibleValue = z;
    return;
  case -1:
    y = x->LowestPossibleValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LowestPossibleValue; n > 1 && y; --n, y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_LowestPossibleValue) */

void zx_hrxml_EducationalMeasure_DEL_LowestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_hrxml_LowestPossibleValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LowestPossibleValue = (struct zx_hrxml_LowestPossibleValue_s*)x->LowestPossibleValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LowestPossibleValue_s*)x->LowestPossibleValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LowestPossibleValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LowestPossibleValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_HighestPossibleValue) */

int zx_hrxml_EducationalMeasure_NUM_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->HighestPossibleValue; y; ++n, y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_HighestPossibleValue) */

struct zx_hrxml_HighestPossibleValue_s* zx_hrxml_EducationalMeasure_GET_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x) return 0;
  for (y = x->HighestPossibleValue; n>=0 && y; --n, y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_HighestPossibleValue) */

struct zx_hrxml_HighestPossibleValue_s* zx_hrxml_EducationalMeasure_POP_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x) return 0;
  y = x->HighestPossibleValue;
  if (y)
    x->HighestPossibleValue = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_HighestPossibleValue) */

void zx_hrxml_EducationalMeasure_PUSH_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, struct zx_hrxml_HighestPossibleValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->HighestPossibleValue->gg.g;
  x->HighestPossibleValue = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_HighestPossibleValue) */

void zx_hrxml_EducationalMeasure_REV_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_hrxml_HighestPossibleValue_s* nxt;
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x) return;
  y = x->HighestPossibleValue;
  if (!y) return;
  x->HighestPossibleValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n;
    y->gg.g.n = &x->HighestPossibleValue->gg.g;
    x->HighestPossibleValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_HighestPossibleValue) */

void zx_hrxml_EducationalMeasure_PUT_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_hrxml_HighestPossibleValue_s* z)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x || !z) return;
  y = x->HighestPossibleValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->HighestPossibleValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_HighestPossibleValue) */

void zx_hrxml_EducationalMeasure_ADD_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_hrxml_HighestPossibleValue_s* z)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->HighestPossibleValue->gg.g;
    x->HighestPossibleValue = z;
    return;
  case -1:
    y = x->HighestPossibleValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->HighestPossibleValue; n > 1 && y; --n, y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_HighestPossibleValue) */

void zx_hrxml_EducationalMeasure_DEL_HighestPossibleValue(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_hrxml_HighestPossibleValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->HighestPossibleValue = (struct zx_hrxml_HighestPossibleValue_s*)x->HighestPossibleValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_HighestPossibleValue_s*)x->HighestPossibleValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->HighestPossibleValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_HighestPossibleValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_ExcessiveValueIndicator) */

int zx_hrxml_EducationalMeasure_NUM_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ExcessiveValueIndicator; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_ExcessiveValueIndicator) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_GET_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ExcessiveValueIndicator; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_ExcessiveValueIndicator) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_POP_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ExcessiveValueIndicator;
  if (y)
    x->ExcessiveValueIndicator = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_ExcessiveValueIndicator) */

void zx_hrxml_EducationalMeasure_PUSH_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ExcessiveValueIndicator->g;
  x->ExcessiveValueIndicator = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_ExcessiveValueIndicator) */

void zx_hrxml_EducationalMeasure_REV_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ExcessiveValueIndicator;
  if (!y) return;
  x->ExcessiveValueIndicator = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ExcessiveValueIndicator->g;
    x->ExcessiveValueIndicator = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_ExcessiveValueIndicator) */

void zx_hrxml_EducationalMeasure_PUT_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ExcessiveValueIndicator;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ExcessiveValueIndicator = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_ExcessiveValueIndicator) */

void zx_hrxml_EducationalMeasure_ADD_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ExcessiveValueIndicator->g;
    x->ExcessiveValueIndicator = z;
    return;
  case -1:
    y = x->ExcessiveValueIndicator;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExcessiveValueIndicator; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_ExcessiveValueIndicator) */

void zx_hrxml_EducationalMeasure_DEL_ExcessiveValueIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ExcessiveValueIndicator = (struct zx_elem_s*)x->ExcessiveValueIndicator->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ExcessiveValueIndicator;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExcessiveValueIndicator; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EducationalMeasure_NUM_GoodStudentIndicator) */

int zx_hrxml_EducationalMeasure_NUM_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->GoodStudentIndicator; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EducationalMeasure_GET_GoodStudentIndicator) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_GET_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->GoodStudentIndicator; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_POP_GoodStudentIndicator) */

struct zx_elem_s* zx_hrxml_EducationalMeasure_POP_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->GoodStudentIndicator;
  if (y)
    x->GoodStudentIndicator = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EducationalMeasure_PUSH_GoodStudentIndicator) */

void zx_hrxml_EducationalMeasure_PUSH_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->GoodStudentIndicator->g;
  x->GoodStudentIndicator = z;
}

/* FUNC(zx_hrxml_EducationalMeasure_REV_GoodStudentIndicator) */

void zx_hrxml_EducationalMeasure_REV_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->GoodStudentIndicator;
  if (!y) return;
  x->GoodStudentIndicator = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->GoodStudentIndicator->g;
    x->GoodStudentIndicator = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_PUT_GoodStudentIndicator) */

void zx_hrxml_EducationalMeasure_PUT_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->GoodStudentIndicator;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->GoodStudentIndicator = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EducationalMeasure_ADD_GoodStudentIndicator) */

void zx_hrxml_EducationalMeasure_ADD_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->GoodStudentIndicator->g;
    x->GoodStudentIndicator = z;
    return;
  case -1:
    y = x->GoodStudentIndicator;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GoodStudentIndicator; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EducationalMeasure_DEL_GoodStudentIndicator) */

void zx_hrxml_EducationalMeasure_DEL_GoodStudentIndicator(struct zx_hrxml_EducationalMeasure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->GoodStudentIndicator = (struct zx_elem_s*)x->GoodStudentIndicator->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->GoodStudentIndicator;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GoodStudentIndicator; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EffectiveDate_NUM_StartDate) */

int zx_hrxml_EffectiveDate_NUM_StartDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EffectiveDate_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_EffectiveDate_GET_StartDate(struct zx_hrxml_EffectiveDate_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EffectiveDate_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_EffectiveDate_POP_StartDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EffectiveDate_PUSH_StartDate) */

void zx_hrxml_EffectiveDate_PUSH_StartDate(struct zx_hrxml_EffectiveDate_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_EffectiveDate_REV_StartDate) */

void zx_hrxml_EffectiveDate_REV_StartDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EffectiveDate_PUT_StartDate) */

void zx_hrxml_EffectiveDate_PUT_StartDate(struct zx_hrxml_EffectiveDate_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EffectiveDate_ADD_StartDate) */

void zx_hrxml_EffectiveDate_ADD_StartDate(struct zx_hrxml_EffectiveDate_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EffectiveDate_DEL_StartDate) */

void zx_hrxml_EffectiveDate_DEL_StartDate(struct zx_hrxml_EffectiveDate_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EffectiveDate_NUM_EndDate) */

int zx_hrxml_EffectiveDate_NUM_EndDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EffectiveDate_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_EffectiveDate_GET_EndDate(struct zx_hrxml_EffectiveDate_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EffectiveDate_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_EffectiveDate_POP_EndDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EffectiveDate_PUSH_EndDate) */

void zx_hrxml_EffectiveDate_PUSH_EndDate(struct zx_hrxml_EffectiveDate_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_EffectiveDate_REV_EndDate) */

void zx_hrxml_EffectiveDate_REV_EndDate(struct zx_hrxml_EffectiveDate_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EffectiveDate_PUT_EndDate) */

void zx_hrxml_EffectiveDate_PUT_EndDate(struct zx_hrxml_EffectiveDate_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EffectiveDate_ADD_EndDate) */

void zx_hrxml_EffectiveDate_ADD_EndDate(struct zx_hrxml_EffectiveDate_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EffectiveDate_DEL_EndDate) */

void zx_hrxml_EffectiveDate_DEL_EndDate(struct zx_hrxml_EffectiveDate_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerContactInfo_NUM_PersonName) */

int zx_hrxml_EmployerContactInfo_NUM_PersonName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerContactInfo_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_EmployerContactInfo_GET_PersonName(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_EmployerContactInfo_POP_PersonName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUSH_PersonName) */

void zx_hrxml_EmployerContactInfo_PUSH_PersonName(struct zx_hrxml_EmployerContactInfo_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_EmployerContactInfo_REV_PersonName) */

void zx_hrxml_EmployerContactInfo_REV_PersonName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUT_PersonName) */

void zx_hrxml_EmployerContactInfo_PUT_PersonName(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_ADD_PersonName) */

void zx_hrxml_EmployerContactInfo_ADD_PersonName(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerContactInfo_DEL_PersonName) */

void zx_hrxml_EmployerContactInfo_DEL_PersonName(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerContactInfo_NUM_ContactMethod) */

int zx_hrxml_EmployerContactInfo_NUM_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerContactInfo_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_EmployerContactInfo_GET_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_EmployerContactInfo_POP_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUSH_ContactMethod) */

void zx_hrxml_EmployerContactInfo_PUSH_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_EmployerContactInfo_REV_ContactMethod) */

void zx_hrxml_EmployerContactInfo_REV_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUT_ContactMethod) */

void zx_hrxml_EmployerContactInfo_PUT_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_ADD_ContactMethod) */

void zx_hrxml_EmployerContactInfo_ADD_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerContactInfo_DEL_ContactMethod) */

void zx_hrxml_EmployerContactInfo_DEL_ContactMethod(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerContactInfo_NUM_LocationSummary) */

int zx_hrxml_EmployerContactInfo_NUM_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LocationSummary; y; ++n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerContactInfo_GET_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_EmployerContactInfo_GET_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  for (y = x->LocationSummary; n>=0 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_POP_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_EmployerContactInfo_POP_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  y = x->LocationSummary;
  if (y)
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUSH_LocationSummary) */

void zx_hrxml_EmployerContactInfo_PUSH_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x, struct zx_hrxml_LocationSummary_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LocationSummary->gg.g;
  x->LocationSummary = z;
}

/* FUNC(zx_hrxml_EmployerContactInfo_REV_LocationSummary) */

void zx_hrxml_EmployerContactInfo_REV_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* nxt;
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  y = x->LocationSummary;
  if (!y) return;
  x->LocationSummary = 0;
  while (y) {
    nxt = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
    y->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUT_LocationSummary) */

void zx_hrxml_EmployerContactInfo_PUT_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  y = x->LocationSummary;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LocationSummary = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_ADD_LocationSummary) */

void zx_hrxml_EmployerContactInfo_ADD_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = z;
    return;
  case -1:
    y = x->LocationSummary;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerContactInfo_DEL_LocationSummary) */

void zx_hrxml_EmployerContactInfo_DEL_LocationSummary(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerContactInfo_NUM_InternetDomainName) */

int zx_hrxml_EmployerContactInfo_NUM_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InternetDomainName; y; ++n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerContactInfo_GET_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_EmployerContactInfo_GET_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  for (y = x->InternetDomainName; n>=0 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_POP_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_EmployerContactInfo_POP_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  y = x->InternetDomainName;
  if (y)
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUSH_InternetDomainName) */

void zx_hrxml_EmployerContactInfo_PUSH_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x, struct zx_hrxml_InternetDomainName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->InternetDomainName->gg.g;
  x->InternetDomainName = z;
}

/* FUNC(zx_hrxml_EmployerContactInfo_REV_InternetDomainName) */

void zx_hrxml_EmployerContactInfo_REV_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x)
{
  struct zx_hrxml_InternetDomainName_s* nxt;
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  y = x->InternetDomainName;
  if (!y) return;
  x->InternetDomainName = 0;
  while (y) {
    nxt = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
    y->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_PUT_InternetDomainName) */

void zx_hrxml_EmployerContactInfo_PUT_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  y = x->InternetDomainName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->InternetDomainName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerContactInfo_ADD_InternetDomainName) */

void zx_hrxml_EmployerContactInfo_ADD_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = z;
    return;
  case -1:
    y = x->InternetDomainName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerContactInfo_DEL_InternetDomainName) */

void zx_hrxml_EmployerContactInfo_DEL_InternetDomainName(struct zx_hrxml_EmployerContactInfo_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_EmployerContactInfo_GET_contactType) */
struct zx_str* zx_hrxml_EmployerContactInfo_GET_contactType(struct zx_hrxml_EmployerContactInfo_s* x) { return x->contactType; }
/* FUNC(zx_hrxml_EmployerContactInfo_PUT_contactType) */
void zx_hrxml_EmployerContactInfo_PUT_contactType(struct zx_hrxml_EmployerContactInfo_s* x, struct zx_str* y) { x->contactType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerOrg_NUM_EmployerOrgName) */

int zx_hrxml_EmployerOrg_NUM_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EmployerOrgName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerOrg_GET_EmployerOrgName) */

struct zx_elem_s* zx_hrxml_EmployerOrg_GET_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EmployerOrgName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_POP_EmployerOrgName) */

struct zx_elem_s* zx_hrxml_EmployerOrg_POP_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EmployerOrgName;
  if (y)
    x->EmployerOrgName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_PUSH_EmployerOrgName) */

void zx_hrxml_EmployerOrg_PUSH_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EmployerOrgName->g;
  x->EmployerOrgName = z;
}

/* FUNC(zx_hrxml_EmployerOrg_REV_EmployerOrgName) */

void zx_hrxml_EmployerOrg_REV_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EmployerOrgName;
  if (!y) return;
  x->EmployerOrgName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EmployerOrgName->g;
    x->EmployerOrgName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_PUT_EmployerOrgName) */

void zx_hrxml_EmployerOrg_PUT_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EmployerOrgName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EmployerOrgName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_ADD_EmployerOrgName) */

void zx_hrxml_EmployerOrg_ADD_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EmployerOrgName->g;
    x->EmployerOrgName = z;
    return;
  case -1:
    y = x->EmployerOrgName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EmployerOrgName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EmployerOrg_DEL_EmployerOrgName) */

void zx_hrxml_EmployerOrg_DEL_EmployerOrgName(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EmployerOrgName = (struct zx_elem_s*)x->EmployerOrgName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EmployerOrgName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EmployerOrgName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerOrg_NUM_EmployerContactInfo) */

int zx_hrxml_EmployerOrg_NUM_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EmployerContactInfo; y; ++n, y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerOrg_GET_EmployerContactInfo) */

struct zx_hrxml_EmployerContactInfo_s* zx_hrxml_EmployerOrg_GET_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x) return 0;
  for (y = x->EmployerContactInfo; n>=0 && y; --n, y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_POP_EmployerContactInfo) */

struct zx_hrxml_EmployerContactInfo_s* zx_hrxml_EmployerOrg_POP_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x) return 0;
  y = x->EmployerContactInfo;
  if (y)
    x->EmployerContactInfo = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_PUSH_EmployerContactInfo) */

void zx_hrxml_EmployerOrg_PUSH_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x, struct zx_hrxml_EmployerContactInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EmployerContactInfo->gg.g;
  x->EmployerContactInfo = z;
}

/* FUNC(zx_hrxml_EmployerOrg_REV_EmployerContactInfo) */

void zx_hrxml_EmployerOrg_REV_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_EmployerContactInfo_s* nxt;
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x) return;
  y = x->EmployerContactInfo;
  if (!y) return;
  x->EmployerContactInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->EmployerContactInfo->gg.g;
    x->EmployerContactInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_PUT_EmployerContactInfo) */

void zx_hrxml_EmployerOrg_PUT_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_EmployerContactInfo_s* z)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x || !z) return;
  y = x->EmployerContactInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EmployerContactInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_ADD_EmployerContactInfo) */

void zx_hrxml_EmployerOrg_ADD_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_EmployerContactInfo_s* z)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EmployerContactInfo->gg.g;
    x->EmployerContactInfo = z;
    return;
  case -1:
    y = x->EmployerContactInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmployerContactInfo; n > 1 && y; --n, y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerOrg_DEL_EmployerContactInfo) */

void zx_hrxml_EmployerOrg_DEL_EmployerContactInfo(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_EmployerContactInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EmployerContactInfo = (struct zx_hrxml_EmployerContactInfo_s*)x->EmployerContactInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EmployerContactInfo_s*)x->EmployerContactInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmployerContactInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmployerContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerOrg_NUM_PositionHistory) */

int zx_hrxml_EmployerOrg_NUM_PositionHistory(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_PositionHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionHistory; y; ++n, y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerOrg_GET_PositionHistory) */

struct zx_hrxml_PositionHistory_s* zx_hrxml_EmployerOrg_GET_PositionHistory(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_PositionHistory_s* y;
  if (!x) return 0;
  for (y = x->PositionHistory; n>=0 && y; --n, y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_POP_PositionHistory) */

struct zx_hrxml_PositionHistory_s* zx_hrxml_EmployerOrg_POP_PositionHistory(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_PositionHistory_s* y;
  if (!x) return 0;
  y = x->PositionHistory;
  if (y)
    x->PositionHistory = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_PUSH_PositionHistory) */

void zx_hrxml_EmployerOrg_PUSH_PositionHistory(struct zx_hrxml_EmployerOrg_s* x, struct zx_hrxml_PositionHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PositionHistory->gg.g;
  x->PositionHistory = z;
}

/* FUNC(zx_hrxml_EmployerOrg_REV_PositionHistory) */

void zx_hrxml_EmployerOrg_REV_PositionHistory(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_PositionHistory_s* nxt;
  struct zx_hrxml_PositionHistory_s* y;
  if (!x) return;
  y = x->PositionHistory;
  if (!y) return;
  x->PositionHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->PositionHistory->gg.g;
    x->PositionHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_PUT_PositionHistory) */

void zx_hrxml_EmployerOrg_PUT_PositionHistory(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_PositionHistory_s* z)
{
  struct zx_hrxml_PositionHistory_s* y;
  if (!x || !z) return;
  y = x->PositionHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PositionHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_ADD_PositionHistory) */

void zx_hrxml_EmployerOrg_ADD_PositionHistory(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_PositionHistory_s* z)
{
  struct zx_hrxml_PositionHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PositionHistory->gg.g;
    x->PositionHistory = z;
    return;
  case -1:
    y = x->PositionHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionHistory; n > 1 && y; --n, y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerOrg_DEL_PositionHistory) */

void zx_hrxml_EmployerOrg_DEL_PositionHistory(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_PositionHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionHistory = (struct zx_hrxml_PositionHistory_s*)x->PositionHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PositionHistory_s*)x->PositionHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmployerOrg_NUM_UserArea) */

int zx_hrxml_EmployerOrg_NUM_UserArea(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmployerOrg_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_EmployerOrg_GET_UserArea(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_EmployerOrg_POP_UserArea(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmployerOrg_PUSH_UserArea) */

void zx_hrxml_EmployerOrg_PUSH_UserArea(struct zx_hrxml_EmployerOrg_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_EmployerOrg_REV_UserArea) */

void zx_hrxml_EmployerOrg_REV_UserArea(struct zx_hrxml_EmployerOrg_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_PUT_UserArea) */

void zx_hrxml_EmployerOrg_PUT_UserArea(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmployerOrg_ADD_UserArea) */

void zx_hrxml_EmployerOrg_ADD_UserArea(struct zx_hrxml_EmployerOrg_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmployerOrg_DEL_UserArea) */

void zx_hrxml_EmployerOrg_DEL_UserArea(struct zx_hrxml_EmployerOrg_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_EmployerOrg_GET_employerOrgType) */
struct zx_str* zx_hrxml_EmployerOrg_GET_employerOrgType(struct zx_hrxml_EmployerOrg_s* x) { return x->employerOrgType; }
/* FUNC(zx_hrxml_EmployerOrg_PUT_employerOrgType) */
void zx_hrxml_EmployerOrg_PUT_employerOrgType(struct zx_hrxml_EmployerOrg_s* x, struct zx_str* y) { x->employerOrgType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EmploymentHistory_NUM_EmployerOrg) */

int zx_hrxml_EmploymentHistory_NUM_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x)
{
  struct zx_hrxml_EmployerOrg_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EmployerOrg; y; ++n, y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EmploymentHistory_GET_EmployerOrg) */

struct zx_hrxml_EmployerOrg_s* zx_hrxml_EmploymentHistory_GET_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x, int n)
{
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x) return 0;
  for (y = x->EmployerOrg; n>=0 && y; --n, y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EmploymentHistory_POP_EmployerOrg) */

struct zx_hrxml_EmployerOrg_s* zx_hrxml_EmploymentHistory_POP_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x)
{
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x) return 0;
  y = x->EmployerOrg;
  if (y)
    x->EmployerOrg = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EmploymentHistory_PUSH_EmployerOrg) */

void zx_hrxml_EmploymentHistory_PUSH_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x, struct zx_hrxml_EmployerOrg_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EmployerOrg->gg.g;
  x->EmployerOrg = z;
}

/* FUNC(zx_hrxml_EmploymentHistory_REV_EmployerOrg) */

void zx_hrxml_EmploymentHistory_REV_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x)
{
  struct zx_hrxml_EmployerOrg_s* nxt;
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x) return;
  y = x->EmployerOrg;
  if (!y) return;
  x->EmployerOrg = 0;
  while (y) {
    nxt = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n;
    y->gg.g.n = &x->EmployerOrg->gg.g;
    x->EmployerOrg = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EmploymentHistory_PUT_EmployerOrg) */

void zx_hrxml_EmploymentHistory_PUT_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x, int n, struct zx_hrxml_EmployerOrg_s* z)
{
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x || !z) return;
  y = x->EmployerOrg;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EmployerOrg = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EmploymentHistory_ADD_EmployerOrg) */

void zx_hrxml_EmploymentHistory_ADD_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x, int n, struct zx_hrxml_EmployerOrg_s* z)
{
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EmployerOrg->gg.g;
    x->EmployerOrg = z;
    return;
  case -1:
    y = x->EmployerOrg;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmployerOrg; n > 1 && y; --n, y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EmploymentHistory_DEL_EmployerOrg) */

void zx_hrxml_EmploymentHistory_DEL_EmployerOrg(struct zx_hrxml_EmploymentHistory_s* x, int n)
{
  struct zx_hrxml_EmployerOrg_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EmployerOrg = (struct zx_hrxml_EmployerOrg_s*)x->EmployerOrg->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EmployerOrg_s*)x->EmployerOrg;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmployerOrg; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmployerOrg_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EndDate_NUM_AnyDate) */

int zx_hrxml_EndDate_NUM_AnyDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EndDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_EndDate_GET_AnyDate(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EndDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_EndDate_POP_AnyDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EndDate_PUSH_AnyDate) */

void zx_hrxml_EndDate_PUSH_AnyDate(struct zx_hrxml_EndDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_EndDate_REV_AnyDate) */

void zx_hrxml_EndDate_REV_AnyDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EndDate_PUT_AnyDate) */

void zx_hrxml_EndDate_PUT_AnyDate(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EndDate_ADD_AnyDate) */

void zx_hrxml_EndDate_ADD_AnyDate(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EndDate_DEL_AnyDate) */

void zx_hrxml_EndDate_DEL_AnyDate(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EndDate_NUM_YearMonth) */

int zx_hrxml_EndDate_NUM_YearMonth(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EndDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_EndDate_GET_YearMonth(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EndDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_EndDate_POP_YearMonth(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EndDate_PUSH_YearMonth) */

void zx_hrxml_EndDate_PUSH_YearMonth(struct zx_hrxml_EndDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_EndDate_REV_YearMonth) */

void zx_hrxml_EndDate_REV_YearMonth(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EndDate_PUT_YearMonth) */

void zx_hrxml_EndDate_PUT_YearMonth(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EndDate_ADD_YearMonth) */

void zx_hrxml_EndDate_ADD_YearMonth(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EndDate_DEL_YearMonth) */

void zx_hrxml_EndDate_DEL_YearMonth(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EndDate_NUM_Year) */

int zx_hrxml_EndDate_NUM_Year(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EndDate_GET_Year) */

struct zx_elem_s* zx_hrxml_EndDate_GET_Year(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EndDate_POP_Year) */

struct zx_elem_s* zx_hrxml_EndDate_POP_Year(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EndDate_PUSH_Year) */

void zx_hrxml_EndDate_PUSH_Year(struct zx_hrxml_EndDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_EndDate_REV_Year) */

void zx_hrxml_EndDate_REV_Year(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EndDate_PUT_Year) */

void zx_hrxml_EndDate_PUT_Year(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EndDate_ADD_Year) */

void zx_hrxml_EndDate_ADD_Year(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EndDate_DEL_Year) */

void zx_hrxml_EndDate_DEL_Year(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EndDate_NUM_MonthDay) */

int zx_hrxml_EndDate_NUM_MonthDay(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EndDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_EndDate_GET_MonthDay(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EndDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_EndDate_POP_MonthDay(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EndDate_PUSH_MonthDay) */

void zx_hrxml_EndDate_PUSH_MonthDay(struct zx_hrxml_EndDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_EndDate_REV_MonthDay) */

void zx_hrxml_EndDate_REV_MonthDay(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EndDate_PUT_MonthDay) */

void zx_hrxml_EndDate_PUT_MonthDay(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EndDate_ADD_MonthDay) */

void zx_hrxml_EndDate_ADD_MonthDay(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EndDate_DEL_MonthDay) */

void zx_hrxml_EndDate_DEL_MonthDay(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EndDate_NUM_StringDate) */

int zx_hrxml_EndDate_NUM_StringDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EndDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_EndDate_GET_StringDate(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EndDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_EndDate_POP_StringDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_EndDate_PUSH_StringDate) */

void zx_hrxml_EndDate_PUSH_StringDate(struct zx_hrxml_EndDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_EndDate_REV_StringDate) */

void zx_hrxml_EndDate_REV_StringDate(struct zx_hrxml_EndDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EndDate_PUT_StringDate) */

void zx_hrxml_EndDate_PUT_StringDate(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_EndDate_ADD_StringDate) */

void zx_hrxml_EndDate_ADD_StringDate(struct zx_hrxml_EndDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_EndDate_DEL_StringDate) */

void zx_hrxml_EndDate_DEL_StringDate(struct zx_hrxml_EndDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_EndDate_GET_dateDescription) */
struct zx_str* zx_hrxml_EndDate_GET_dateDescription(struct zx_hrxml_EndDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_EndDate_PUT_dateDescription) */
void zx_hrxml_EndDate_PUT_dateDescription(struct zx_hrxml_EndDate_s* x, struct zx_str* y) { x->dateDescription = y; }





/* FUNC(zx_hrxml_EndingCompensation_GET_currency) */
struct zx_str* zx_hrxml_EndingCompensation_GET_currency(struct zx_hrxml_EndingCompensation_s* x) { return x->currency; }
/* FUNC(zx_hrxml_EndingCompensation_PUT_currency) */
void zx_hrxml_EndingCompensation_PUT_currency(struct zx_hrxml_EndingCompensation_s* x, struct zx_str* y) { x->currency = y; }
/* FUNC(zx_hrxml_EndingCompensation_GET_intervalType) */
struct zx_str* zx_hrxml_EndingCompensation_GET_intervalType(struct zx_hrxml_EndingCompensation_s* x) { return x->intervalType; }
/* FUNC(zx_hrxml_EndingCompensation_PUT_intervalType) */
void zx_hrxml_EndingCompensation_PUT_intervalType(struct zx_hrxml_EndingCompensation_s* x, struct zx_str* y) { x->intervalType = y; }
/* FUNC(zx_hrxml_EndingCompensation_GET_validFrom) */
struct zx_str* zx_hrxml_EndingCompensation_GET_validFrom(struct zx_hrxml_EndingCompensation_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_EndingCompensation_PUT_validFrom) */
void zx_hrxml_EndingCompensation_PUT_validFrom(struct zx_hrxml_EndingCompensation_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_EndingCompensation_GET_validTo) */
struct zx_str* zx_hrxml_EndingCompensation_GET_validTo(struct zx_hrxml_EndingCompensation_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_EndingCompensation_PUT_validTo) */
void zx_hrxml_EndingCompensation_PUT_validTo(struct zx_hrxml_EndingCompensation_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_EnvironmentId_NUM_IdValue) */

int zx_hrxml_EnvironmentId_NUM_IdValue(struct zx_hrxml_EnvironmentId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_EnvironmentId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_EnvironmentId_GET_IdValue(struct zx_hrxml_EnvironmentId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_EnvironmentId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_EnvironmentId_POP_IdValue(struct zx_hrxml_EnvironmentId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_EnvironmentId_PUSH_IdValue) */

void zx_hrxml_EnvironmentId_PUSH_IdValue(struct zx_hrxml_EnvironmentId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_EnvironmentId_REV_IdValue) */

void zx_hrxml_EnvironmentId_REV_IdValue(struct zx_hrxml_EnvironmentId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_EnvironmentId_PUT_IdValue) */

void zx_hrxml_EnvironmentId_PUT_IdValue(struct zx_hrxml_EnvironmentId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_EnvironmentId_ADD_IdValue) */

void zx_hrxml_EnvironmentId_ADD_IdValue(struct zx_hrxml_EnvironmentId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_EnvironmentId_DEL_IdValue) */

void zx_hrxml_EnvironmentId_DEL_IdValue(struct zx_hrxml_EnvironmentId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_EnvironmentId_GET_idOwner) */
struct zx_str* zx_hrxml_EnvironmentId_GET_idOwner(struct zx_hrxml_EnvironmentId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_EnvironmentId_PUT_idOwner) */
void zx_hrxml_EnvironmentId_PUT_idOwner(struct zx_hrxml_EnvironmentId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_EnvironmentId_GET_validFrom) */
struct zx_str* zx_hrxml_EnvironmentId_GET_validFrom(struct zx_hrxml_EnvironmentId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_EnvironmentId_PUT_validFrom) */
void zx_hrxml_EnvironmentId_PUT_validFrom(struct zx_hrxml_EnvironmentId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_EnvironmentId_GET_validTo) */
struct zx_str* zx_hrxml_EnvironmentId_GET_validTo(struct zx_hrxml_EnvironmentId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_EnvironmentId_PUT_validTo) */
void zx_hrxml_EnvironmentId_PUT_validTo(struct zx_hrxml_EnvironmentId_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_EvidenceId_GET_description) */
struct zx_str* zx_hrxml_EvidenceId_GET_description(struct zx_hrxml_EvidenceId_s* x) { return x->description; }
/* FUNC(zx_hrxml_EvidenceId_PUT_description) */
void zx_hrxml_EvidenceId_PUT_description(struct zx_hrxml_EvidenceId_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_EvidenceId_GET_id) */
struct zx_str* zx_hrxml_EvidenceId_GET_id(struct zx_hrxml_EvidenceId_s* x) { return x->id; }
/* FUNC(zx_hrxml_EvidenceId_PUT_id) */
void zx_hrxml_EvidenceId_PUT_id(struct zx_hrxml_EvidenceId_s* x, struct zx_str* y) { x->id = y; }
/* FUNC(zx_hrxml_EvidenceId_GET_idOwner) */
struct zx_str* zx_hrxml_EvidenceId_GET_idOwner(struct zx_hrxml_EvidenceId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_EvidenceId_PUT_idOwner) */
void zx_hrxml_EvidenceId_PUT_idOwner(struct zx_hrxml_EvidenceId_s* x, struct zx_str* y) { x->idOwner = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ExpatriateBenefits_NUM_ExpatriateBenefitsOffered) */

int zx_hrxml_ExpatriateBenefits_NUM_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ExpatriateBenefitsOffered; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_GET_ExpatriateBenefitsOffered) */

struct zx_elem_s* zx_hrxml_ExpatriateBenefits_GET_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ExpatriateBenefitsOffered; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_POP_ExpatriateBenefitsOffered) */

struct zx_elem_s* zx_hrxml_ExpatriateBenefits_POP_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ExpatriateBenefitsOffered;
  if (y)
    x->ExpatriateBenefitsOffered = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_PUSH_ExpatriateBenefitsOffered) */

void zx_hrxml_ExpatriateBenefits_PUSH_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ExpatriateBenefitsOffered->g;
  x->ExpatriateBenefitsOffered = z;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_REV_ExpatriateBenefitsOffered) */

void zx_hrxml_ExpatriateBenefits_REV_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ExpatriateBenefitsOffered;
  if (!y) return;
  x->ExpatriateBenefitsOffered = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ExpatriateBenefitsOffered->g;
    x->ExpatriateBenefitsOffered = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ExpatriateBenefits_PUT_ExpatriateBenefitsOffered) */

void zx_hrxml_ExpatriateBenefits_PUT_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ExpatriateBenefitsOffered;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ExpatriateBenefitsOffered = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ExpatriateBenefits_ADD_ExpatriateBenefitsOffered) */

void zx_hrxml_ExpatriateBenefits_ADD_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ExpatriateBenefitsOffered->g;
    x->ExpatriateBenefitsOffered = z;
    return;
  case -1:
    y = x->ExpatriateBenefitsOffered;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefitsOffered; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_DEL_ExpatriateBenefitsOffered) */

void zx_hrxml_ExpatriateBenefits_DEL_ExpatriateBenefitsOffered(struct zx_hrxml_ExpatriateBenefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ExpatriateBenefitsOffered = (struct zx_elem_s*)x->ExpatriateBenefitsOffered->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ExpatriateBenefitsOffered;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefitsOffered; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ExpatriateBenefits_NUM_ExpatriateBenefitList) */

int zx_hrxml_ExpatriateBenefits_NUM_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ExpatriateBenefitList; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_GET_ExpatriateBenefitList) */

struct zx_elem_s* zx_hrxml_ExpatriateBenefits_GET_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ExpatriateBenefitList; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_POP_ExpatriateBenefitList) */

struct zx_elem_s* zx_hrxml_ExpatriateBenefits_POP_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ExpatriateBenefitList;
  if (y)
    x->ExpatriateBenefitList = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_PUSH_ExpatriateBenefitList) */

void zx_hrxml_ExpatriateBenefits_PUSH_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ExpatriateBenefitList->g;
  x->ExpatriateBenefitList = z;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_REV_ExpatriateBenefitList) */

void zx_hrxml_ExpatriateBenefits_REV_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ExpatriateBenefitList;
  if (!y) return;
  x->ExpatriateBenefitList = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ExpatriateBenefitList->g;
    x->ExpatriateBenefitList = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ExpatriateBenefits_PUT_ExpatriateBenefitList) */

void zx_hrxml_ExpatriateBenefits_PUT_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ExpatriateBenefitList;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ExpatriateBenefitList = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ExpatriateBenefits_ADD_ExpatriateBenefitList) */

void zx_hrxml_ExpatriateBenefits_ADD_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ExpatriateBenefitList->g;
    x->ExpatriateBenefitList = z;
    return;
  case -1:
    y = x->ExpatriateBenefitList;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefitList; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ExpatriateBenefits_DEL_ExpatriateBenefitList) */

void zx_hrxml_ExpatriateBenefits_DEL_ExpatriateBenefitList(struct zx_hrxml_ExpatriateBenefits_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ExpatriateBenefitList = (struct zx_elem_s*)x->ExpatriateBenefitList->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ExpatriateBenefitList;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExpatriateBenefitList; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_FamilyName_GET_prefix) */
struct zx_str* zx_hrxml_FamilyName_GET_prefix(struct zx_hrxml_FamilyName_s* x) { return x->prefix; }
/* FUNC(zx_hrxml_FamilyName_PUT_prefix) */
void zx_hrxml_FamilyName_PUT_prefix(struct zx_hrxml_FamilyName_s* x, struct zx_str* y) { x->prefix = y; }
/* FUNC(zx_hrxml_FamilyName_GET_primary) */
struct zx_str* zx_hrxml_FamilyName_GET_primary(struct zx_hrxml_FamilyName_s* x) { return x->primary; }
/* FUNC(zx_hrxml_FamilyName_PUT_primary) */
void zx_hrxml_FamilyName_PUT_primary(struct zx_hrxml_FamilyName_s* x, struct zx_str* y) { x->primary = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Fax_NUM_FormattedNumber) */

int zx_hrxml_Fax_NUM_FormattedNumber(struct zx_hrxml_Fax_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Fax_GET_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Fax_GET_FormattedNumber(struct zx_hrxml_Fax_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Fax_POP_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Fax_POP_FormattedNumber(struct zx_hrxml_Fax_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedNumber;
  if (y)
    x->FormattedNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Fax_PUSH_FormattedNumber) */

void zx_hrxml_Fax_PUSH_FormattedNumber(struct zx_hrxml_Fax_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedNumber->g;
  x->FormattedNumber = z;
}

/* FUNC(zx_hrxml_Fax_REV_FormattedNumber) */

void zx_hrxml_Fax_REV_FormattedNumber(struct zx_hrxml_Fax_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedNumber;
  if (!y) return;
  x->FormattedNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Fax_PUT_FormattedNumber) */

void zx_hrxml_Fax_PUT_FormattedNumber(struct zx_hrxml_Fax_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Fax_ADD_FormattedNumber) */

void zx_hrxml_Fax_ADD_FormattedNumber(struct zx_hrxml_Fax_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = z;
    return;
  case -1:
    y = x->FormattedNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Fax_DEL_FormattedNumber) */

void zx_hrxml_Fax_DEL_FormattedNumber(struct zx_hrxml_Fax_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedNumber = (struct zx_elem_s*)x->FormattedNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_FirstIssuedDate_NUM_AnyDate) */

int zx_hrxml_FirstIssuedDate_NUM_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_FirstIssuedDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_GET_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_POP_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUSH_AnyDate) */

void zx_hrxml_FirstIssuedDate_PUSH_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_FirstIssuedDate_REV_AnyDate) */

void zx_hrxml_FirstIssuedDate_REV_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUT_AnyDate) */

void zx_hrxml_FirstIssuedDate_PUT_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_ADD_AnyDate) */

void zx_hrxml_FirstIssuedDate_ADD_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_FirstIssuedDate_DEL_AnyDate) */

void zx_hrxml_FirstIssuedDate_DEL_AnyDate(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_FirstIssuedDate_NUM_YearMonth) */

int zx_hrxml_FirstIssuedDate_NUM_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_FirstIssuedDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_GET_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_POP_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUSH_YearMonth) */

void zx_hrxml_FirstIssuedDate_PUSH_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_FirstIssuedDate_REV_YearMonth) */

void zx_hrxml_FirstIssuedDate_REV_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUT_YearMonth) */

void zx_hrxml_FirstIssuedDate_PUT_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_ADD_YearMonth) */

void zx_hrxml_FirstIssuedDate_ADD_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_FirstIssuedDate_DEL_YearMonth) */

void zx_hrxml_FirstIssuedDate_DEL_YearMonth(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_FirstIssuedDate_NUM_Year) */

int zx_hrxml_FirstIssuedDate_NUM_Year(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_FirstIssuedDate_GET_Year) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_GET_Year(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_POP_Year) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_POP_Year(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUSH_Year) */

void zx_hrxml_FirstIssuedDate_PUSH_Year(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_FirstIssuedDate_REV_Year) */

void zx_hrxml_FirstIssuedDate_REV_Year(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUT_Year) */

void zx_hrxml_FirstIssuedDate_PUT_Year(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_ADD_Year) */

void zx_hrxml_FirstIssuedDate_ADD_Year(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_FirstIssuedDate_DEL_Year) */

void zx_hrxml_FirstIssuedDate_DEL_Year(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_FirstIssuedDate_NUM_MonthDay) */

int zx_hrxml_FirstIssuedDate_NUM_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_FirstIssuedDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_GET_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_POP_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUSH_MonthDay) */

void zx_hrxml_FirstIssuedDate_PUSH_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_FirstIssuedDate_REV_MonthDay) */

void zx_hrxml_FirstIssuedDate_REV_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUT_MonthDay) */

void zx_hrxml_FirstIssuedDate_PUT_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_ADD_MonthDay) */

void zx_hrxml_FirstIssuedDate_ADD_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_FirstIssuedDate_DEL_MonthDay) */

void zx_hrxml_FirstIssuedDate_DEL_MonthDay(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_FirstIssuedDate_NUM_StringDate) */

int zx_hrxml_FirstIssuedDate_NUM_StringDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_FirstIssuedDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_GET_StringDate(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_FirstIssuedDate_POP_StringDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUSH_StringDate) */

void zx_hrxml_FirstIssuedDate_PUSH_StringDate(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_FirstIssuedDate_REV_StringDate) */

void zx_hrxml_FirstIssuedDate_REV_StringDate(struct zx_hrxml_FirstIssuedDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_PUT_StringDate) */

void zx_hrxml_FirstIssuedDate_PUT_StringDate(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_FirstIssuedDate_ADD_StringDate) */

void zx_hrxml_FirstIssuedDate_ADD_StringDate(struct zx_hrxml_FirstIssuedDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_FirstIssuedDate_DEL_StringDate) */

void zx_hrxml_FirstIssuedDate_DEL_StringDate(struct zx_hrxml_FirstIssuedDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_FirstIssuedDate_GET_dateDescription) */
struct zx_str* zx_hrxml_FirstIssuedDate_GET_dateDescription(struct zx_hrxml_FirstIssuedDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_FirstIssuedDate_PUT_dateDescription) */
void zx_hrxml_FirstIssuedDate_PUT_dateDescription(struct zx_hrxml_FirstIssuedDate_s* x, struct zx_str* y) { x->dateDescription = y; }





/* FUNC(zx_hrxml_FormattedPublicationDescription_GET_type) */
struct zx_str* zx_hrxml_FormattedPublicationDescription_GET_type(struct zx_hrxml_FormattedPublicationDescription_s* x) { return x->type; }
/* FUNC(zx_hrxml_FormattedPublicationDescription_PUT_type) */
void zx_hrxml_FormattedPublicationDescription_PUT_type(struct zx_hrxml_FormattedPublicationDescription_s* x, struct zx_str* y) { x->type = y; }





/* FUNC(zx_hrxml_Height_GET_unitOfMeasure) */
struct zx_str* zx_hrxml_Height_GET_unitOfMeasure(struct zx_hrxml_Height_s* x) { return x->unitOfMeasure; }
/* FUNC(zx_hrxml_Height_PUT_unitOfMeasure) */
void zx_hrxml_Height_PUT_unitOfMeasure(struct zx_hrxml_Height_s* x, struct zx_str* y) { x->unitOfMeasure = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_HighestPossibleValue_NUM_NumericValue) */

int zx_hrxml_HighestPossibleValue_NUM_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumericValue; y; ++n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_HighestPossibleValue_GET_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_HighestPossibleValue_GET_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  for (y = x->NumericValue; n>=0 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_HighestPossibleValue_POP_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_HighestPossibleValue_POP_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  y = x->NumericValue;
  if (y)
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_HighestPossibleValue_PUSH_NumericValue) */

void zx_hrxml_HighestPossibleValue_PUSH_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x, struct zx_hrxml_NumericValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->NumericValue->gg.g;
  x->NumericValue = z;
}

/* FUNC(zx_hrxml_HighestPossibleValue_REV_NumericValue) */

void zx_hrxml_HighestPossibleValue_REV_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* nxt;
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  y = x->NumericValue;
  if (!y) return;
  x->NumericValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
    y->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_HighestPossibleValue_PUT_NumericValue) */

void zx_hrxml_HighestPossibleValue_PUT_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  y = x->NumericValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->NumericValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_HighestPossibleValue_ADD_NumericValue) */

void zx_hrxml_HighestPossibleValue_ADD_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = z;
    return;
  case -1:
    y = x->NumericValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_HighestPossibleValue_DEL_NumericValue) */

void zx_hrxml_HighestPossibleValue_DEL_NumericValue(struct zx_hrxml_HighestPossibleValue_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)x->NumericValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_NumericValue_s*)x->NumericValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_HighestPossibleValue_NUM_StringValue) */

int zx_hrxml_HighestPossibleValue_NUM_StringValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringValue; y; ++n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_HighestPossibleValue_GET_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_HighestPossibleValue_GET_StringValue(struct zx_hrxml_HighestPossibleValue_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  for (y = x->StringValue; n>=0 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_HighestPossibleValue_POP_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_HighestPossibleValue_POP_StringValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  y = x->StringValue;
  if (y)
    x->StringValue = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_HighestPossibleValue_PUSH_StringValue) */

void zx_hrxml_HighestPossibleValue_PUSH_StringValue(struct zx_hrxml_HighestPossibleValue_s* x, struct zx_hrxml_StringValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StringValue->gg.g;
  x->StringValue = z;
}

/* FUNC(zx_hrxml_HighestPossibleValue_REV_StringValue) */

void zx_hrxml_HighestPossibleValue_REV_StringValue(struct zx_hrxml_HighestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* nxt;
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  y = x->StringValue;
  if (!y) return;
  x->StringValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
    y->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_HighestPossibleValue_PUT_StringValue) */

void zx_hrxml_HighestPossibleValue_PUT_StringValue(struct zx_hrxml_HighestPossibleValue_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  y = x->StringValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StringValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_HighestPossibleValue_ADD_StringValue) */

void zx_hrxml_HighestPossibleValue_ADD_StringValue(struct zx_hrxml_HighestPossibleValue_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = z;
    return;
  case -1:
    y = x->StringValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_HighestPossibleValue_DEL_StringValue) */

void zx_hrxml_HighestPossibleValue_DEL_StringValue(struct zx_hrxml_HighestPossibleValue_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringValue = (struct zx_hrxml_StringValue_s*)x->StringValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StringValue_s*)x->StringValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif













#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Id_NUM_IdValue) */

int zx_hrxml_Id_NUM_IdValue(struct zx_hrxml_Id_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Id_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_Id_GET_IdValue(struct zx_hrxml_Id_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Id_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_Id_POP_IdValue(struct zx_hrxml_Id_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Id_PUSH_IdValue) */

void zx_hrxml_Id_PUSH_IdValue(struct zx_hrxml_Id_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_Id_REV_IdValue) */

void zx_hrxml_Id_REV_IdValue(struct zx_hrxml_Id_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Id_PUT_IdValue) */

void zx_hrxml_Id_PUT_IdValue(struct zx_hrxml_Id_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Id_ADD_IdValue) */

void zx_hrxml_Id_ADD_IdValue(struct zx_hrxml_Id_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Id_DEL_IdValue) */

void zx_hrxml_Id_DEL_IdValue(struct zx_hrxml_Id_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Id_GET_idOwner) */
struct zx_str* zx_hrxml_Id_GET_idOwner(struct zx_hrxml_Id_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_Id_PUT_idOwner) */
void zx_hrxml_Id_PUT_idOwner(struct zx_hrxml_Id_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_Id_GET_validFrom) */
struct zx_str* zx_hrxml_Id_GET_validFrom(struct zx_hrxml_Id_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_Id_PUT_validFrom) */
void zx_hrxml_Id_PUT_validFrom(struct zx_hrxml_Id_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_Id_GET_validTo) */
struct zx_str* zx_hrxml_Id_GET_validTo(struct zx_hrxml_Id_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_Id_PUT_validTo) */
void zx_hrxml_Id_PUT_validTo(struct zx_hrxml_Id_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_IdValue_GET_name) */
struct zx_str* zx_hrxml_IdValue_GET_name(struct zx_hrxml_IdValue_s* x) { return x->name; }
/* FUNC(zx_hrxml_IdValue_PUT_name) */
void zx_hrxml_IdValue_PUT_name(struct zx_hrxml_IdValue_s* x, struct zx_str* y) { x->name = y; }





/* FUNC(zx_hrxml_IndustryCode_GET_classificationName) */
struct zx_str* zx_hrxml_IndustryCode_GET_classificationName(struct zx_hrxml_IndustryCode_s* x) { return x->classificationName; }
/* FUNC(zx_hrxml_IndustryCode_PUT_classificationName) */
void zx_hrxml_IndustryCode_PUT_classificationName(struct zx_hrxml_IndustryCode_s* x, struct zx_str* y) { x->classificationName = y; }
/* FUNC(zx_hrxml_IndustryCode_GET_primaryIndicator) */
struct zx_str* zx_hrxml_IndustryCode_GET_primaryIndicator(struct zx_hrxml_IndustryCode_s* x) { return x->primaryIndicator; }
/* FUNC(zx_hrxml_IndustryCode_PUT_primaryIndicator) */
void zx_hrxml_IndustryCode_PUT_primaryIndicator(struct zx_hrxml_IndustryCode_s* x, struct zx_str* y) { x->primaryIndicator = y; }





/* FUNC(zx_hrxml_Insurance_GET_type) */
struct zx_str* zx_hrxml_Insurance_GET_type(struct zx_hrxml_Insurance_s* x) { return x->type; }
/* FUNC(zx_hrxml_Insurance_PUT_type) */
void zx_hrxml_Insurance_PUT_type(struct zx_hrxml_Insurance_s* x, struct zx_str* y) { x->type = y; }





/* FUNC(zx_hrxml_InternetDomainName_GET_primaryIndicator) */
struct zx_str* zx_hrxml_InternetDomainName_GET_primaryIndicator(struct zx_hrxml_InternetDomainName_s* x) { return x->primaryIndicator; }
/* FUNC(zx_hrxml_InternetDomainName_PUT_primaryIndicator) */
void zx_hrxml_InternetDomainName_PUT_primaryIndicator(struct zx_hrxml_InternetDomainName_s* x, struct zx_str* y) { x->primaryIndicator = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Inventors_NUM_InventorName) */

int zx_hrxml_Inventors_NUM_InventorName(struct zx_hrxml_Inventors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InventorName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Inventors_GET_InventorName) */

struct zx_elem_s* zx_hrxml_Inventors_GET_InventorName(struct zx_hrxml_Inventors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->InventorName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Inventors_POP_InventorName) */

struct zx_elem_s* zx_hrxml_Inventors_POP_InventorName(struct zx_hrxml_Inventors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->InventorName;
  if (y)
    x->InventorName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Inventors_PUSH_InventorName) */

void zx_hrxml_Inventors_PUSH_InventorName(struct zx_hrxml_Inventors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->InventorName->g;
  x->InventorName = z;
}

/* FUNC(zx_hrxml_Inventors_REV_InventorName) */

void zx_hrxml_Inventors_REV_InventorName(struct zx_hrxml_Inventors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->InventorName;
  if (!y) return;
  x->InventorName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->InventorName->g;
    x->InventorName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Inventors_PUT_InventorName) */

void zx_hrxml_Inventors_PUT_InventorName(struct zx_hrxml_Inventors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->InventorName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->InventorName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Inventors_ADD_InventorName) */

void zx_hrxml_Inventors_ADD_InventorName(struct zx_hrxml_Inventors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->InventorName->g;
    x->InventorName = z;
    return;
  case -1:
    y = x->InventorName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InventorName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Inventors_DEL_InventorName) */

void zx_hrxml_Inventors_DEL_InventorName(struct zx_hrxml_Inventors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InventorName = (struct zx_elem_s*)x->InventorName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->InventorName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->InventorName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_IssuingAuthority_GET_countryCode) */
struct zx_str* zx_hrxml_IssuingAuthority_GET_countryCode(struct zx_hrxml_IssuingAuthority_s* x) { return x->countryCode; }
/* FUNC(zx_hrxml_IssuingAuthority_PUT_countryCode) */
void zx_hrxml_IssuingAuthority_PUT_countryCode(struct zx_hrxml_IssuingAuthority_s* x, struct zx_str* y) { x->countryCode = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobCategory_NUM_TaxonomyName) */

int zx_hrxml_JobCategory_NUM_TaxonomyName(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_TaxonomyName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TaxonomyName; y; ++n, y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobCategory_GET_TaxonomyName) */

struct zx_hrxml_TaxonomyName_s* zx_hrxml_JobCategory_GET_TaxonomyName(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x) return 0;
  for (y = x->TaxonomyName; n>=0 && y; --n, y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_POP_TaxonomyName) */

struct zx_hrxml_TaxonomyName_s* zx_hrxml_JobCategory_POP_TaxonomyName(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x) return 0;
  y = x->TaxonomyName;
  if (y)
    x->TaxonomyName = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_PUSH_TaxonomyName) */

void zx_hrxml_JobCategory_PUSH_TaxonomyName(struct zx_hrxml_JobCategory_s* x, struct zx_hrxml_TaxonomyName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TaxonomyName->gg.g;
  x->TaxonomyName = z;
}

/* FUNC(zx_hrxml_JobCategory_REV_TaxonomyName) */

void zx_hrxml_JobCategory_REV_TaxonomyName(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_TaxonomyName_s* nxt;
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x) return;
  y = x->TaxonomyName;
  if (!y) return;
  x->TaxonomyName = 0;
  while (y) {
    nxt = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n;
    y->gg.g.n = &x->TaxonomyName->gg.g;
    x->TaxonomyName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobCategory_PUT_TaxonomyName) */

void zx_hrxml_JobCategory_PUT_TaxonomyName(struct zx_hrxml_JobCategory_s* x, int n, struct zx_hrxml_TaxonomyName_s* z)
{
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x || !z) return;
  y = x->TaxonomyName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TaxonomyName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_JobCategory_ADD_TaxonomyName) */

void zx_hrxml_JobCategory_ADD_TaxonomyName(struct zx_hrxml_JobCategory_s* x, int n, struct zx_hrxml_TaxonomyName_s* z)
{
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TaxonomyName->gg.g;
    x->TaxonomyName = z;
    return;
  case -1:
    y = x->TaxonomyName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxonomyName; n > 1 && y; --n, y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_JobCategory_DEL_TaxonomyName) */

void zx_hrxml_JobCategory_DEL_TaxonomyName(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_hrxml_TaxonomyName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TaxonomyName = (struct zx_hrxml_TaxonomyName_s*)x->TaxonomyName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TaxonomyName_s*)x->TaxonomyName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxonomyName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxonomyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobCategory_NUM_CategoryCode) */

int zx_hrxml_JobCategory_NUM_CategoryCode(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CategoryCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobCategory_GET_CategoryCode) */

struct zx_elem_s* zx_hrxml_JobCategory_GET_CategoryCode(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CategoryCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_POP_CategoryCode) */

struct zx_elem_s* zx_hrxml_JobCategory_POP_CategoryCode(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CategoryCode;
  if (y)
    x->CategoryCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_PUSH_CategoryCode) */

void zx_hrxml_JobCategory_PUSH_CategoryCode(struct zx_hrxml_JobCategory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CategoryCode->g;
  x->CategoryCode = z;
}

/* FUNC(zx_hrxml_JobCategory_REV_CategoryCode) */

void zx_hrxml_JobCategory_REV_CategoryCode(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CategoryCode;
  if (!y) return;
  x->CategoryCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CategoryCode->g;
    x->CategoryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobCategory_PUT_CategoryCode) */

void zx_hrxml_JobCategory_PUT_CategoryCode(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CategoryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CategoryCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobCategory_ADD_CategoryCode) */

void zx_hrxml_JobCategory_ADD_CategoryCode(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CategoryCode->g;
    x->CategoryCode = z;
    return;
  case -1:
    y = x->CategoryCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CategoryCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobCategory_DEL_CategoryCode) */

void zx_hrxml_JobCategory_DEL_CategoryCode(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CategoryCode = (struct zx_elem_s*)x->CategoryCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CategoryCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CategoryCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobCategory_NUM_CategoryDescription) */

int zx_hrxml_JobCategory_NUM_CategoryDescription(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CategoryDescription; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobCategory_GET_CategoryDescription) */

struct zx_elem_s* zx_hrxml_JobCategory_GET_CategoryDescription(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CategoryDescription; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_POP_CategoryDescription) */

struct zx_elem_s* zx_hrxml_JobCategory_POP_CategoryDescription(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CategoryDescription;
  if (y)
    x->CategoryDescription = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_PUSH_CategoryDescription) */

void zx_hrxml_JobCategory_PUSH_CategoryDescription(struct zx_hrxml_JobCategory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CategoryDescription->g;
  x->CategoryDescription = z;
}

/* FUNC(zx_hrxml_JobCategory_REV_CategoryDescription) */

void zx_hrxml_JobCategory_REV_CategoryDescription(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CategoryDescription;
  if (!y) return;
  x->CategoryDescription = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CategoryDescription->g;
    x->CategoryDescription = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobCategory_PUT_CategoryDescription) */

void zx_hrxml_JobCategory_PUT_CategoryDescription(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CategoryDescription;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CategoryDescription = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobCategory_ADD_CategoryDescription) */

void zx_hrxml_JobCategory_ADD_CategoryDescription(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CategoryDescription->g;
    x->CategoryDescription = z;
    return;
  case -1:
    y = x->CategoryDescription;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CategoryDescription; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobCategory_DEL_CategoryDescription) */

void zx_hrxml_JobCategory_DEL_CategoryDescription(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CategoryDescription = (struct zx_elem_s*)x->CategoryDescription->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CategoryDescription;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CategoryDescription; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobCategory_NUM_Comments) */

int zx_hrxml_JobCategory_NUM_Comments(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobCategory_GET_Comments) */

struct zx_elem_s* zx_hrxml_JobCategory_GET_Comments(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_POP_Comments) */

struct zx_elem_s* zx_hrxml_JobCategory_POP_Comments(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_PUSH_Comments) */

void zx_hrxml_JobCategory_PUSH_Comments(struct zx_hrxml_JobCategory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_JobCategory_REV_Comments) */

void zx_hrxml_JobCategory_REV_Comments(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobCategory_PUT_Comments) */

void zx_hrxml_JobCategory_PUT_Comments(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobCategory_ADD_Comments) */

void zx_hrxml_JobCategory_ADD_Comments(struct zx_hrxml_JobCategory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobCategory_DEL_Comments) */

void zx_hrxml_JobCategory_DEL_Comments(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobCategory_NUM_JobCategory) */

int zx_hrxml_JobCategory_NUM_JobCategory(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobCategory; y; ++n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobCategory_GET_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_JobCategory_GET_JobCategory(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  for (y = x->JobCategory; n>=0 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_POP_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_JobCategory_POP_JobCategory(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  y = x->JobCategory;
  if (y)
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_JobCategory_PUSH_JobCategory) */

void zx_hrxml_JobCategory_PUSH_JobCategory(struct zx_hrxml_JobCategory_s* x, struct zx_hrxml_JobCategory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->JobCategory->gg.g;
  x->JobCategory = z;
}

/* FUNC(zx_hrxml_JobCategory_REV_JobCategory) */

void zx_hrxml_JobCategory_REV_JobCategory(struct zx_hrxml_JobCategory_s* x)
{
  struct zx_hrxml_JobCategory_s* nxt;
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  y = x->JobCategory;
  if (!y) return;
  x->JobCategory = 0;
  while (y) {
    nxt = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
    y->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobCategory_PUT_JobCategory) */

void zx_hrxml_JobCategory_PUT_JobCategory(struct zx_hrxml_JobCategory_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  y = x->JobCategory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->JobCategory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_JobCategory_ADD_JobCategory) */

void zx_hrxml_JobCategory_ADD_JobCategory(struct zx_hrxml_JobCategory_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = z;
    return;
  case -1:
    y = x->JobCategory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_JobCategory_DEL_JobCategory) */

void zx_hrxml_JobCategory_DEL_JobCategory(struct zx_hrxml_JobCategory_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)x->JobCategory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_JobCategory_s*)x->JobCategory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobLevelInfo_NUM_JobPlan) */

int zx_hrxml_JobLevelInfo_NUM_JobPlan(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobPlan; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobLevelInfo_GET_JobPlan) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_GET_JobPlan(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->JobPlan; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_POP_JobPlan) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_POP_JobPlan(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->JobPlan;
  if (y)
    x->JobPlan = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_PUSH_JobPlan) */

void zx_hrxml_JobLevelInfo_PUSH_JobPlan(struct zx_hrxml_JobLevelInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->JobPlan->g;
  x->JobPlan = z;
}

/* FUNC(zx_hrxml_JobLevelInfo_REV_JobPlan) */

void zx_hrxml_JobLevelInfo_REV_JobPlan(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->JobPlan;
  if (!y) return;
  x->JobPlan = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->JobPlan->g;
    x->JobPlan = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_PUT_JobPlan) */

void zx_hrxml_JobLevelInfo_PUT_JobPlan(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->JobPlan;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->JobPlan = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_ADD_JobPlan) */

void zx_hrxml_JobLevelInfo_ADD_JobPlan(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->JobPlan->g;
    x->JobPlan = z;
    return;
  case -1:
    y = x->JobPlan;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobPlan; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobLevelInfo_DEL_JobPlan) */

void zx_hrxml_JobLevelInfo_DEL_JobPlan(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobPlan = (struct zx_elem_s*)x->JobPlan->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->JobPlan;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobPlan; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobLevelInfo_NUM_JobGrade) */

int zx_hrxml_JobLevelInfo_NUM_JobGrade(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobGrade; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobLevelInfo_GET_JobGrade) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_GET_JobGrade(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->JobGrade; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_POP_JobGrade) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_POP_JobGrade(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->JobGrade;
  if (y)
    x->JobGrade = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_PUSH_JobGrade) */

void zx_hrxml_JobLevelInfo_PUSH_JobGrade(struct zx_hrxml_JobLevelInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->JobGrade->g;
  x->JobGrade = z;
}

/* FUNC(zx_hrxml_JobLevelInfo_REV_JobGrade) */

void zx_hrxml_JobLevelInfo_REV_JobGrade(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->JobGrade;
  if (!y) return;
  x->JobGrade = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->JobGrade->g;
    x->JobGrade = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_PUT_JobGrade) */

void zx_hrxml_JobLevelInfo_PUT_JobGrade(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->JobGrade;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->JobGrade = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_ADD_JobGrade) */

void zx_hrxml_JobLevelInfo_ADD_JobGrade(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->JobGrade->g;
    x->JobGrade = z;
    return;
  case -1:
    y = x->JobGrade;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobGrade; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobLevelInfo_DEL_JobGrade) */

void zx_hrxml_JobLevelInfo_DEL_JobGrade(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobGrade = (struct zx_elem_s*)x->JobGrade->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->JobGrade;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobGrade; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobLevelInfo_NUM_JobStep) */

int zx_hrxml_JobLevelInfo_NUM_JobStep(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobStep; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobLevelInfo_GET_JobStep) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_GET_JobStep(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->JobStep; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_POP_JobStep) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_POP_JobStep(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->JobStep;
  if (y)
    x->JobStep = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_PUSH_JobStep) */

void zx_hrxml_JobLevelInfo_PUSH_JobStep(struct zx_hrxml_JobLevelInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->JobStep->g;
  x->JobStep = z;
}

/* FUNC(zx_hrxml_JobLevelInfo_REV_JobStep) */

void zx_hrxml_JobLevelInfo_REV_JobStep(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->JobStep;
  if (!y) return;
  x->JobStep = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->JobStep->g;
    x->JobStep = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_PUT_JobStep) */

void zx_hrxml_JobLevelInfo_PUT_JobStep(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->JobStep;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->JobStep = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_ADD_JobStep) */

void zx_hrxml_JobLevelInfo_ADD_JobStep(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->JobStep->g;
    x->JobStep = z;
    return;
  case -1:
    y = x->JobStep;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobStep; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobLevelInfo_DEL_JobStep) */

void zx_hrxml_JobLevelInfo_DEL_JobStep(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobStep = (struct zx_elem_s*)x->JobStep->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->JobStep;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->JobStep; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_JobLevelInfo_NUM_Comments) */

int zx_hrxml_JobLevelInfo_NUM_Comments(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_JobLevelInfo_GET_Comments) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_GET_Comments(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_POP_Comments) */

struct zx_elem_s* zx_hrxml_JobLevelInfo_POP_Comments(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_JobLevelInfo_PUSH_Comments) */

void zx_hrxml_JobLevelInfo_PUSH_Comments(struct zx_hrxml_JobLevelInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_JobLevelInfo_REV_Comments) */

void zx_hrxml_JobLevelInfo_REV_Comments(struct zx_hrxml_JobLevelInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_PUT_Comments) */

void zx_hrxml_JobLevelInfo_PUT_Comments(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_JobLevelInfo_ADD_Comments) */

void zx_hrxml_JobLevelInfo_ADD_Comments(struct zx_hrxml_JobLevelInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_JobLevelInfo_DEL_Comments) */

void zx_hrxml_JobLevelInfo_DEL_Comments(struct zx_hrxml_JobLevelInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Language_NUM_LanguageCode) */

int zx_hrxml_Language_NUM_LanguageCode(struct zx_hrxml_Language_s* x)
{
  struct zx_hrxml_LanguageCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LanguageCode; y; ++n, y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Language_GET_LanguageCode) */

struct zx_hrxml_LanguageCode_s* zx_hrxml_Language_GET_LanguageCode(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_hrxml_LanguageCode_s* y;
  if (!x) return 0;
  for (y = x->LanguageCode; n>=0 && y; --n, y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Language_POP_LanguageCode) */

struct zx_hrxml_LanguageCode_s* zx_hrxml_Language_POP_LanguageCode(struct zx_hrxml_Language_s* x)
{
  struct zx_hrxml_LanguageCode_s* y;
  if (!x) return 0;
  y = x->LanguageCode;
  if (y)
    x->LanguageCode = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Language_PUSH_LanguageCode) */

void zx_hrxml_Language_PUSH_LanguageCode(struct zx_hrxml_Language_s* x, struct zx_hrxml_LanguageCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LanguageCode->gg.g;
  x->LanguageCode = z;
}

/* FUNC(zx_hrxml_Language_REV_LanguageCode) */

void zx_hrxml_Language_REV_LanguageCode(struct zx_hrxml_Language_s* x)
{
  struct zx_hrxml_LanguageCode_s* nxt;
  struct zx_hrxml_LanguageCode_s* y;
  if (!x) return;
  y = x->LanguageCode;
  if (!y) return;
  x->LanguageCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n;
    y->gg.g.n = &x->LanguageCode->gg.g;
    x->LanguageCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Language_PUT_LanguageCode) */

void zx_hrxml_Language_PUT_LanguageCode(struct zx_hrxml_Language_s* x, int n, struct zx_hrxml_LanguageCode_s* z)
{
  struct zx_hrxml_LanguageCode_s* y;
  if (!x || !z) return;
  y = x->LanguageCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LanguageCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Language_ADD_LanguageCode) */

void zx_hrxml_Language_ADD_LanguageCode(struct zx_hrxml_Language_s* x, int n, struct zx_hrxml_LanguageCode_s* z)
{
  struct zx_hrxml_LanguageCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LanguageCode->gg.g;
    x->LanguageCode = z;
    return;
  case -1:
    y = x->LanguageCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LanguageCode; n > 1 && y; --n, y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Language_DEL_LanguageCode) */

void zx_hrxml_Language_DEL_LanguageCode(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_hrxml_LanguageCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LanguageCode = (struct zx_hrxml_LanguageCode_s*)x->LanguageCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LanguageCode_s*)x->LanguageCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LanguageCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LanguageCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Language_NUM_Read) */

int zx_hrxml_Language_NUM_Read(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Read; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Language_GET_Read) */

struct zx_elem_s* zx_hrxml_Language_GET_Read(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Read; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Language_POP_Read) */

struct zx_elem_s* zx_hrxml_Language_POP_Read(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Read;
  if (y)
    x->Read = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Language_PUSH_Read) */

void zx_hrxml_Language_PUSH_Read(struct zx_hrxml_Language_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Read->g;
  x->Read = z;
}

/* FUNC(zx_hrxml_Language_REV_Read) */

void zx_hrxml_Language_REV_Read(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Read;
  if (!y) return;
  x->Read = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Read->g;
    x->Read = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Language_PUT_Read) */

void zx_hrxml_Language_PUT_Read(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Read;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Read = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Language_ADD_Read) */

void zx_hrxml_Language_ADD_Read(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Read->g;
    x->Read = z;
    return;
  case -1:
    y = x->Read;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Read; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Language_DEL_Read) */

void zx_hrxml_Language_DEL_Read(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Read = (struct zx_elem_s*)x->Read->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Read;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Read; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Language_NUM_Write) */

int zx_hrxml_Language_NUM_Write(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Write; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Language_GET_Write) */

struct zx_elem_s* zx_hrxml_Language_GET_Write(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Write; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Language_POP_Write) */

struct zx_elem_s* zx_hrxml_Language_POP_Write(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Write;
  if (y)
    x->Write = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Language_PUSH_Write) */

void zx_hrxml_Language_PUSH_Write(struct zx_hrxml_Language_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Write->g;
  x->Write = z;
}

/* FUNC(zx_hrxml_Language_REV_Write) */

void zx_hrxml_Language_REV_Write(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Write;
  if (!y) return;
  x->Write = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Write->g;
    x->Write = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Language_PUT_Write) */

void zx_hrxml_Language_PUT_Write(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Write;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Write = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Language_ADD_Write) */

void zx_hrxml_Language_ADD_Write(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Write->g;
    x->Write = z;
    return;
  case -1:
    y = x->Write;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Write; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Language_DEL_Write) */

void zx_hrxml_Language_DEL_Write(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Write = (struct zx_elem_s*)x->Write->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Write;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Write; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Language_NUM_Speak) */

int zx_hrxml_Language_NUM_Speak(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Speak; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Language_GET_Speak) */

struct zx_elem_s* zx_hrxml_Language_GET_Speak(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Speak; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Language_POP_Speak) */

struct zx_elem_s* zx_hrxml_Language_POP_Speak(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Speak;
  if (y)
    x->Speak = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Language_PUSH_Speak) */

void zx_hrxml_Language_PUSH_Speak(struct zx_hrxml_Language_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Speak->g;
  x->Speak = z;
}

/* FUNC(zx_hrxml_Language_REV_Speak) */

void zx_hrxml_Language_REV_Speak(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Speak;
  if (!y) return;
  x->Speak = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Speak->g;
    x->Speak = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Language_PUT_Speak) */

void zx_hrxml_Language_PUT_Speak(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Speak;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Speak = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Language_ADD_Speak) */

void zx_hrxml_Language_ADD_Speak(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Speak->g;
    x->Speak = z;
    return;
  case -1:
    y = x->Speak;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Speak; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Language_DEL_Speak) */

void zx_hrxml_Language_DEL_Speak(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Speak = (struct zx_elem_s*)x->Speak->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Speak;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Speak; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Language_NUM_Comments) */

int zx_hrxml_Language_NUM_Comments(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Language_GET_Comments) */

struct zx_elem_s* zx_hrxml_Language_GET_Comments(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Language_POP_Comments) */

struct zx_elem_s* zx_hrxml_Language_POP_Comments(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Language_PUSH_Comments) */

void zx_hrxml_Language_PUSH_Comments(struct zx_hrxml_Language_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Language_REV_Comments) */

void zx_hrxml_Language_REV_Comments(struct zx_hrxml_Language_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Language_PUT_Comments) */

void zx_hrxml_Language_PUT_Comments(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Language_ADD_Comments) */

void zx_hrxml_Language_ADD_Comments(struct zx_hrxml_Language_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Language_DEL_Comments) */

void zx_hrxml_Language_DEL_Comments(struct zx_hrxml_Language_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif













#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Languages_NUM_Language) */

int zx_hrxml_Languages_NUM_Language(struct zx_hrxml_Languages_s* x)
{
  struct zx_hrxml_Language_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Language; y; ++n, y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Languages_GET_Language) */

struct zx_hrxml_Language_s* zx_hrxml_Languages_GET_Language(struct zx_hrxml_Languages_s* x, int n)
{
  struct zx_hrxml_Language_s* y;
  if (!x) return 0;
  for (y = x->Language; n>=0 && y; --n, y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Languages_POP_Language) */

struct zx_hrxml_Language_s* zx_hrxml_Languages_POP_Language(struct zx_hrxml_Languages_s* x)
{
  struct zx_hrxml_Language_s* y;
  if (!x) return 0;
  y = x->Language;
  if (y)
    x->Language = (struct zx_hrxml_Language_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Languages_PUSH_Language) */

void zx_hrxml_Languages_PUSH_Language(struct zx_hrxml_Languages_s* x, struct zx_hrxml_Language_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Language->gg.g;
  x->Language = z;
}

/* FUNC(zx_hrxml_Languages_REV_Language) */

void zx_hrxml_Languages_REV_Language(struct zx_hrxml_Languages_s* x)
{
  struct zx_hrxml_Language_s* nxt;
  struct zx_hrxml_Language_s* y;
  if (!x) return;
  y = x->Language;
  if (!y) return;
  x->Language = 0;
  while (y) {
    nxt = (struct zx_hrxml_Language_s*)y->gg.g.n;
    y->gg.g.n = &x->Language->gg.g;
    x->Language = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Languages_PUT_Language) */

void zx_hrxml_Languages_PUT_Language(struct zx_hrxml_Languages_s* x, int n, struct zx_hrxml_Language_s* z)
{
  struct zx_hrxml_Language_s* y;
  if (!x || !z) return;
  y = x->Language;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Language = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Languages_ADD_Language) */

void zx_hrxml_Languages_ADD_Language(struct zx_hrxml_Languages_s* x, int n, struct zx_hrxml_Language_s* z)
{
  struct zx_hrxml_Language_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Language->gg.g;
    x->Language = z;
    return;
  case -1:
    y = x->Language;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Language; n > 1 && y; --n, y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Languages_DEL_Language) */

void zx_hrxml_Languages_DEL_Language(struct zx_hrxml_Languages_s* x, int n)
{
  struct zx_hrxml_Language_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Language = (struct zx_hrxml_Language_s*)x->Language->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Language_s*)x->Language;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Language; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Language_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif











/* FUNC(zx_hrxml_LegalClassification_GET_countryCode) */
struct zx_str* zx_hrxml_LegalClassification_GET_countryCode(struct zx_hrxml_LegalClassification_s* x) { return x->countryCode; }
/* FUNC(zx_hrxml_LegalClassification_PUT_countryCode) */
void zx_hrxml_LegalClassification_PUT_countryCode(struct zx_hrxml_LegalClassification_s* x, struct zx_str* y) { x->countryCode = y; }
/* FUNC(zx_hrxml_LegalClassification_GET_ownership) */
struct zx_str* zx_hrxml_LegalClassification_GET_ownership(struct zx_hrxml_LegalClassification_s* x) { return x->ownership; }
/* FUNC(zx_hrxml_LegalClassification_PUT_ownership) */
void zx_hrxml_LegalClassification_PUT_ownership(struct zx_hrxml_LegalClassification_s* x, struct zx_str* y) { x->ownership = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalId_NUM_IdValue) */

int zx_hrxml_LegalId_NUM_IdValue(struct zx_hrxml_LegalId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_LegalId_GET_IdValue(struct zx_hrxml_LegalId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_LegalId_POP_IdValue(struct zx_hrxml_LegalId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalId_PUSH_IdValue) */

void zx_hrxml_LegalId_PUSH_IdValue(struct zx_hrxml_LegalId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_LegalId_REV_IdValue) */

void zx_hrxml_LegalId_REV_IdValue(struct zx_hrxml_LegalId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalId_PUT_IdValue) */

void zx_hrxml_LegalId_PUT_IdValue(struct zx_hrxml_LegalId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LegalId_ADD_IdValue) */

void zx_hrxml_LegalId_ADD_IdValue(struct zx_hrxml_LegalId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LegalId_DEL_IdValue) */

void zx_hrxml_LegalId_DEL_IdValue(struct zx_hrxml_LegalId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_LegalId_GET_idOwner) */
struct zx_str* zx_hrxml_LegalId_GET_idOwner(struct zx_hrxml_LegalId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_LegalId_PUT_idOwner) */
void zx_hrxml_LegalId_PUT_idOwner(struct zx_hrxml_LegalId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_LegalId_GET_validFrom) */
struct zx_str* zx_hrxml_LegalId_GET_validFrom(struct zx_hrxml_LegalId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_LegalId_PUT_validFrom) */
void zx_hrxml_LegalId_PUT_validFrom(struct zx_hrxml_LegalId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_LegalId_GET_validTo) */
struct zx_str* zx_hrxml_LegalId_GET_validTo(struct zx_hrxml_LegalId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_LegalId_PUT_validTo) */
void zx_hrxml_LegalId_PUT_validTo(struct zx_hrxml_LegalId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_PersonLegalId) */

int zx_hrxml_LegalIdentifiers_NUM_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_PersonLegalId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonLegalId; y; ++n, y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_PersonLegalId) */

struct zx_hrxml_PersonLegalId_s* zx_hrxml_LegalIdentifiers_GET_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x) return 0;
  for (y = x->PersonLegalId; n>=0 && y; --n, y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_PersonLegalId) */

struct zx_hrxml_PersonLegalId_s* zx_hrxml_LegalIdentifiers_POP_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x) return 0;
  y = x->PersonLegalId;
  if (y)
    x->PersonLegalId = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_PersonLegalId) */

void zx_hrxml_LegalIdentifiers_PUSH_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_hrxml_PersonLegalId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonLegalId->gg.g;
  x->PersonLegalId = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_PersonLegalId) */

void zx_hrxml_LegalIdentifiers_REV_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_PersonLegalId_s* nxt;
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x) return;
  y = x->PersonLegalId;
  if (!y) return;
  x->PersonLegalId = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonLegalId->gg.g;
    x->PersonLegalId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_PersonLegalId) */

void zx_hrxml_LegalIdentifiers_PUT_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_PersonLegalId_s* z)
{
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x || !z) return;
  y = x->PersonLegalId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonLegalId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_PersonLegalId) */

void zx_hrxml_LegalIdentifiers_ADD_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_PersonLegalId_s* z)
{
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonLegalId->gg.g;
    x->PersonLegalId = z;
    return;
  case -1:
    y = x->PersonLegalId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonLegalId; n > 1 && y; --n, y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_PersonLegalId) */

void zx_hrxml_LegalIdentifiers_DEL_PersonLegalId(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_PersonLegalId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonLegalId = (struct zx_hrxml_PersonLegalId_s*)x->PersonLegalId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonLegalId_s*)x->PersonLegalId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonLegalId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonLegalId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_MilitaryStatus) */

int zx_hrxml_LegalIdentifiers_NUM_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MilitaryStatus; y; ++n, y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_MilitaryStatus) */

struct zx_hrxml_MilitaryStatus_s* zx_hrxml_LegalIdentifiers_GET_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x) return 0;
  for (y = x->MilitaryStatus; n>=0 && y; --n, y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_MilitaryStatus) */

struct zx_hrxml_MilitaryStatus_s* zx_hrxml_LegalIdentifiers_POP_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x) return 0;
  y = x->MilitaryStatus;
  if (y)
    x->MilitaryStatus = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_MilitaryStatus) */

void zx_hrxml_LegalIdentifiers_PUSH_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_hrxml_MilitaryStatus_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->MilitaryStatus->gg.g;
  x->MilitaryStatus = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_MilitaryStatus) */

void zx_hrxml_LegalIdentifiers_REV_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_MilitaryStatus_s* nxt;
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x) return;
  y = x->MilitaryStatus;
  if (!y) return;
  x->MilitaryStatus = 0;
  while (y) {
    nxt = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n;
    y->gg.g.n = &x->MilitaryStatus->gg.g;
    x->MilitaryStatus = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_MilitaryStatus) */

void zx_hrxml_LegalIdentifiers_PUT_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_MilitaryStatus_s* z)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x || !z) return;
  y = x->MilitaryStatus;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->MilitaryStatus = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_MilitaryStatus) */

void zx_hrxml_LegalIdentifiers_ADD_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_MilitaryStatus_s* z)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->MilitaryStatus->gg.g;
    x->MilitaryStatus = z;
    return;
  case -1:
    y = x->MilitaryStatus;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryStatus; n > 1 && y; --n, y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_MilitaryStatus) */

void zx_hrxml_LegalIdentifiers_DEL_MilitaryStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_MilitaryStatus_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MilitaryStatus = (struct zx_hrxml_MilitaryStatus_s*)x->MilitaryStatus->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_MilitaryStatus_s*)x->MilitaryStatus;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryStatus; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryStatus_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_VisaStatus) */

int zx_hrxml_LegalIdentifiers_NUM_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_VisaStatus_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->VisaStatus; y; ++n, y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_VisaStatus) */

struct zx_hrxml_VisaStatus_s* zx_hrxml_LegalIdentifiers_GET_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_VisaStatus_s* y;
  if (!x) return 0;
  for (y = x->VisaStatus; n>=0 && y; --n, y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_VisaStatus) */

struct zx_hrxml_VisaStatus_s* zx_hrxml_LegalIdentifiers_POP_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_VisaStatus_s* y;
  if (!x) return 0;
  y = x->VisaStatus;
  if (y)
    x->VisaStatus = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_VisaStatus) */

void zx_hrxml_LegalIdentifiers_PUSH_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_hrxml_VisaStatus_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->VisaStatus->gg.g;
  x->VisaStatus = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_VisaStatus) */

void zx_hrxml_LegalIdentifiers_REV_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_VisaStatus_s* nxt;
  struct zx_hrxml_VisaStatus_s* y;
  if (!x) return;
  y = x->VisaStatus;
  if (!y) return;
  x->VisaStatus = 0;
  while (y) {
    nxt = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n;
    y->gg.g.n = &x->VisaStatus->gg.g;
    x->VisaStatus = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_VisaStatus) */

void zx_hrxml_LegalIdentifiers_PUT_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_VisaStatus_s* z)
{
  struct zx_hrxml_VisaStatus_s* y;
  if (!x || !z) return;
  y = x->VisaStatus;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->VisaStatus = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_VisaStatus) */

void zx_hrxml_LegalIdentifiers_ADD_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_VisaStatus_s* z)
{
  struct zx_hrxml_VisaStatus_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->VisaStatus->gg.g;
    x->VisaStatus = z;
    return;
  case -1:
    y = x->VisaStatus;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->VisaStatus; n > 1 && y; --n, y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_VisaStatus) */

void zx_hrxml_LegalIdentifiers_DEL_VisaStatus(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_VisaStatus_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->VisaStatus = (struct zx_hrxml_VisaStatus_s*)x->VisaStatus->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_VisaStatus_s*)x->VisaStatus;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->VisaStatus; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_VisaStatus_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_Citizenship) */

int zx_hrxml_LegalIdentifiers_NUM_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Citizenship; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_Citizenship) */

struct zx_elem_s* zx_hrxml_LegalIdentifiers_GET_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Citizenship; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_Citizenship) */

struct zx_elem_s* zx_hrxml_LegalIdentifiers_POP_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Citizenship;
  if (y)
    x->Citizenship = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_Citizenship) */

void zx_hrxml_LegalIdentifiers_PUSH_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Citizenship->g;
  x->Citizenship = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_Citizenship) */

void zx_hrxml_LegalIdentifiers_REV_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Citizenship;
  if (!y) return;
  x->Citizenship = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Citizenship->g;
    x->Citizenship = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_Citizenship) */

void zx_hrxml_LegalIdentifiers_PUT_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Citizenship;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Citizenship = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_Citizenship) */

void zx_hrxml_LegalIdentifiers_ADD_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Citizenship->g;
    x->Citizenship = z;
    return;
  case -1:
    y = x->Citizenship;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Citizenship; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_Citizenship) */

void zx_hrxml_LegalIdentifiers_DEL_Citizenship(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Citizenship = (struct zx_elem_s*)x->Citizenship->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Citizenship;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Citizenship; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_Residency) */

int zx_hrxml_LegalIdentifiers_NUM_Residency(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Residency; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_Residency) */

struct zx_elem_s* zx_hrxml_LegalIdentifiers_GET_Residency(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Residency; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_Residency) */

struct zx_elem_s* zx_hrxml_LegalIdentifiers_POP_Residency(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Residency;
  if (y)
    x->Residency = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_Residency) */

void zx_hrxml_LegalIdentifiers_PUSH_Residency(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Residency->g;
  x->Residency = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_Residency) */

void zx_hrxml_LegalIdentifiers_REV_Residency(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Residency;
  if (!y) return;
  x->Residency = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Residency->g;
    x->Residency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_Residency) */

void zx_hrxml_LegalIdentifiers_PUT_Residency(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Residency;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Residency = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_Residency) */

void zx_hrxml_LegalIdentifiers_ADD_Residency(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Residency->g;
    x->Residency = z;
    return;
  case -1:
    y = x->Residency;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Residency; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_Residency) */

void zx_hrxml_LegalIdentifiers_DEL_Residency(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Residency = (struct zx_elem_s*)x->Residency->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Residency;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Residency; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LegalIdentifiers_NUM_UserArea) */

int zx_hrxml_LegalIdentifiers_NUM_UserArea(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LegalIdentifiers_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_LegalIdentifiers_GET_UserArea(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_LegalIdentifiers_POP_UserArea(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUSH_UserArea) */

void zx_hrxml_LegalIdentifiers_PUSH_UserArea(struct zx_hrxml_LegalIdentifiers_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_LegalIdentifiers_REV_UserArea) */

void zx_hrxml_LegalIdentifiers_REV_UserArea(struct zx_hrxml_LegalIdentifiers_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_PUT_UserArea) */

void zx_hrxml_LegalIdentifiers_PUT_UserArea(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LegalIdentifiers_ADD_UserArea) */

void zx_hrxml_LegalIdentifiers_ADD_UserArea(struct zx_hrxml_LegalIdentifiers_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LegalIdentifiers_DEL_UserArea) */

void zx_hrxml_LegalIdentifiers_DEL_UserArea(struct zx_hrxml_LegalIdentifiers_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicenseOrCertification_NUM_Name) */

int zx_hrxml_LicenseOrCertification_NUM_Name(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicenseOrCertification_GET_Name) */

struct zx_elem_s* zx_hrxml_LicenseOrCertification_GET_Name(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_POP_Name) */

struct zx_elem_s* zx_hrxml_LicenseOrCertification_POP_Name(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUSH_Name) */

void zx_hrxml_LicenseOrCertification_PUSH_Name(struct zx_hrxml_LicenseOrCertification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_LicenseOrCertification_REV_Name) */

void zx_hrxml_LicenseOrCertification_REV_Name(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUT_Name) */

void zx_hrxml_LicenseOrCertification_PUT_Name(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_ADD_Name) */

void zx_hrxml_LicenseOrCertification_ADD_Name(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LicenseOrCertification_DEL_Name) */

void zx_hrxml_LicenseOrCertification_DEL_Name(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicenseOrCertification_NUM_Id) */

int zx_hrxml_LicenseOrCertification_NUM_Id(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicenseOrCertification_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_LicenseOrCertification_GET_Id(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_LicenseOrCertification_POP_Id(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUSH_Id) */

void zx_hrxml_LicenseOrCertification_PUSH_Id(struct zx_hrxml_LicenseOrCertification_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_LicenseOrCertification_REV_Id) */

void zx_hrxml_LicenseOrCertification_REV_Id(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUT_Id) */

void zx_hrxml_LicenseOrCertification_PUT_Id(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_ADD_Id) */

void zx_hrxml_LicenseOrCertification_ADD_Id(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LicenseOrCertification_DEL_Id) */

void zx_hrxml_LicenseOrCertification_DEL_Id(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicenseOrCertification_NUM_IssuingAuthority) */

int zx_hrxml_LicenseOrCertification_NUM_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IssuingAuthority; y; ++n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicenseOrCertification_GET_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_LicenseOrCertification_GET_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  for (y = x->IssuingAuthority; n>=0 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_POP_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_LicenseOrCertification_POP_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  y = x->IssuingAuthority;
  if (y)
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUSH_IssuingAuthority) */

void zx_hrxml_LicenseOrCertification_PUSH_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x, struct zx_hrxml_IssuingAuthority_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IssuingAuthority->gg.g;
  x->IssuingAuthority = z;
}

/* FUNC(zx_hrxml_LicenseOrCertification_REV_IssuingAuthority) */

void zx_hrxml_LicenseOrCertification_REV_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* nxt;
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  y = x->IssuingAuthority;
  if (!y) return;
  x->IssuingAuthority = 0;
  while (y) {
    nxt = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
    y->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUT_IssuingAuthority) */

void zx_hrxml_LicenseOrCertification_PUT_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  y = x->IssuingAuthority;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IssuingAuthority = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_ADD_IssuingAuthority) */

void zx_hrxml_LicenseOrCertification_ADD_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = z;
    return;
  case -1:
    y = x->IssuingAuthority;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LicenseOrCertification_DEL_IssuingAuthority) */

void zx_hrxml_LicenseOrCertification_DEL_IssuingAuthority(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicenseOrCertification_NUM_Description) */

int zx_hrxml_LicenseOrCertification_NUM_Description(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicenseOrCertification_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_LicenseOrCertification_GET_Description(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_LicenseOrCertification_POP_Description(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUSH_Description) */

void zx_hrxml_LicenseOrCertification_PUSH_Description(struct zx_hrxml_LicenseOrCertification_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_LicenseOrCertification_REV_Description) */

void zx_hrxml_LicenseOrCertification_REV_Description(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUT_Description) */

void zx_hrxml_LicenseOrCertification_PUT_Description(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_ADD_Description) */

void zx_hrxml_LicenseOrCertification_ADD_Description(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LicenseOrCertification_DEL_Description) */

void zx_hrxml_LicenseOrCertification_DEL_Description(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicenseOrCertification_NUM_EffectiveDate) */

int zx_hrxml_LicenseOrCertification_NUM_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EffectiveDate; y; ++n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicenseOrCertification_GET_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_LicenseOrCertification_GET_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  for (y = x->EffectiveDate; n>=0 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_POP_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_LicenseOrCertification_POP_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  y = x->EffectiveDate;
  if (y)
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUSH_EffectiveDate) */

void zx_hrxml_LicenseOrCertification_PUSH_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x, struct zx_hrxml_EffectiveDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EffectiveDate->gg.g;
  x->EffectiveDate = z;
}

/* FUNC(zx_hrxml_LicenseOrCertification_REV_EffectiveDate) */

void zx_hrxml_LicenseOrCertification_REV_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x)
{
  struct zx_hrxml_EffectiveDate_s* nxt;
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  y = x->EffectiveDate;
  if (!y) return;
  x->EffectiveDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_PUT_EffectiveDate) */

void zx_hrxml_LicenseOrCertification_PUT_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  y = x->EffectiveDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EffectiveDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LicenseOrCertification_ADD_EffectiveDate) */

void zx_hrxml_LicenseOrCertification_ADD_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = z;
    return;
  case -1:
    y = x->EffectiveDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LicenseOrCertification_DEL_EffectiveDate) */

void zx_hrxml_LicenseOrCertification_DEL_EffectiveDate(struct zx_hrxml_LicenseOrCertification_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LicensesAndCertifications_NUM_LicenseOrCertification) */

int zx_hrxml_LicensesAndCertifications_NUM_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LicenseOrCertification; y; ++n, y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LicensesAndCertifications_GET_LicenseOrCertification) */

struct zx_hrxml_LicenseOrCertification_s* zx_hrxml_LicensesAndCertifications_GET_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x, int n)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x) return 0;
  for (y = x->LicenseOrCertification; n>=0 && y; --n, y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LicensesAndCertifications_POP_LicenseOrCertification) */

struct zx_hrxml_LicenseOrCertification_s* zx_hrxml_LicensesAndCertifications_POP_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x) return 0;
  y = x->LicenseOrCertification;
  if (y)
    x->LicenseOrCertification = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LicensesAndCertifications_PUSH_LicenseOrCertification) */

void zx_hrxml_LicensesAndCertifications_PUSH_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x, struct zx_hrxml_LicenseOrCertification_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LicenseOrCertification->gg.g;
  x->LicenseOrCertification = z;
}

/* FUNC(zx_hrxml_LicensesAndCertifications_REV_LicenseOrCertification) */

void zx_hrxml_LicensesAndCertifications_REV_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x)
{
  struct zx_hrxml_LicenseOrCertification_s* nxt;
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x) return;
  y = x->LicenseOrCertification;
  if (!y) return;
  x->LicenseOrCertification = 0;
  while (y) {
    nxt = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n;
    y->gg.g.n = &x->LicenseOrCertification->gg.g;
    x->LicenseOrCertification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LicensesAndCertifications_PUT_LicenseOrCertification) */

void zx_hrxml_LicensesAndCertifications_PUT_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x, int n, struct zx_hrxml_LicenseOrCertification_s* z)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x || !z) return;
  y = x->LicenseOrCertification;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LicenseOrCertification = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LicensesAndCertifications_ADD_LicenseOrCertification) */

void zx_hrxml_LicensesAndCertifications_ADD_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x, int n, struct zx_hrxml_LicenseOrCertification_s* z)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LicenseOrCertification->gg.g;
    x->LicenseOrCertification = z;
    return;
  case -1:
    y = x->LicenseOrCertification;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LicenseOrCertification; n > 1 && y; --n, y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LicensesAndCertifications_DEL_LicenseOrCertification) */

void zx_hrxml_LicensesAndCertifications_DEL_LicenseOrCertification(struct zx_hrxml_LicensesAndCertifications_s* x, int n)
{
  struct zx_hrxml_LicenseOrCertification_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LicenseOrCertification = (struct zx_hrxml_LicenseOrCertification_s*)x->LicenseOrCertification->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LicenseOrCertification_s*)x->LicenseOrCertification;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LicenseOrCertification; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LicenseOrCertification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_List_NUM_Item) */

int zx_hrxml_List_NUM_Item(struct zx_hrxml_List_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Item; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_List_GET_Item) */

struct zx_elem_s* zx_hrxml_List_GET_Item(struct zx_hrxml_List_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Item; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_List_POP_Item) */

struct zx_elem_s* zx_hrxml_List_POP_Item(struct zx_hrxml_List_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Item;
  if (y)
    x->Item = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_List_PUSH_Item) */

void zx_hrxml_List_PUSH_Item(struct zx_hrxml_List_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Item->g;
  x->Item = z;
}

/* FUNC(zx_hrxml_List_REV_Item) */

void zx_hrxml_List_REV_Item(struct zx_hrxml_List_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Item;
  if (!y) return;
  x->Item = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Item->g;
    x->Item = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_List_PUT_Item) */

void zx_hrxml_List_PUT_Item(struct zx_hrxml_List_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Item;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Item = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_List_ADD_Item) */

void zx_hrxml_List_ADD_Item(struct zx_hrxml_List_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Item->g;
    x->Item = z;
    return;
  case -1:
    y = x->Item;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Item; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_List_DEL_Item) */

void zx_hrxml_List_DEL_Item(struct zx_hrxml_List_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Item = (struct zx_elem_s*)x->Item->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Item;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Item; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocalInstitutionClassification_NUM_Id) */

int zx_hrxml_LocalInstitutionClassification_NUM_Id(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_LocalInstitutionClassification_GET_Id(struct zx_hrxml_LocalInstitutionClassification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_LocalInstitutionClassification_POP_Id(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_PUSH_Id) */

void zx_hrxml_LocalInstitutionClassification_PUSH_Id(struct zx_hrxml_LocalInstitutionClassification_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_REV_Id) */

void zx_hrxml_LocalInstitutionClassification_REV_Id(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_PUT_Id) */

void zx_hrxml_LocalInstitutionClassification_PUT_Id(struct zx_hrxml_LocalInstitutionClassification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_ADD_Id) */

void zx_hrxml_LocalInstitutionClassification_ADD_Id(struct zx_hrxml_LocalInstitutionClassification_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_DEL_Id) */

void zx_hrxml_LocalInstitutionClassification_DEL_Id(struct zx_hrxml_LocalInstitutionClassification_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocalInstitutionClassification_NUM_Description) */

int zx_hrxml_LocalInstitutionClassification_NUM_Description(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_LocalInstitutionClassification_GET_Description(struct zx_hrxml_LocalInstitutionClassification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_LocalInstitutionClassification_POP_Description(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_PUSH_Description) */

void zx_hrxml_LocalInstitutionClassification_PUSH_Description(struct zx_hrxml_LocalInstitutionClassification_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_REV_Description) */

void zx_hrxml_LocalInstitutionClassification_REV_Description(struct zx_hrxml_LocalInstitutionClassification_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_PUT_Description) */

void zx_hrxml_LocalInstitutionClassification_PUT_Description(struct zx_hrxml_LocalInstitutionClassification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_ADD_Description) */

void zx_hrxml_LocalInstitutionClassification_ADD_Description(struct zx_hrxml_LocalInstitutionClassification_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LocalInstitutionClassification_DEL_Description) */

void zx_hrxml_LocalInstitutionClassification_DEL_Description(struct zx_hrxml_LocalInstitutionClassification_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocationSummary_NUM_Municipality) */

int zx_hrxml_LocationSummary_NUM_Municipality(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Municipality; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocationSummary_GET_Municipality) */

struct zx_elem_s* zx_hrxml_LocationSummary_GET_Municipality(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Municipality; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_POP_Municipality) */

struct zx_elem_s* zx_hrxml_LocationSummary_POP_Municipality(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Municipality;
  if (y)
    x->Municipality = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_PUSH_Municipality) */

void zx_hrxml_LocationSummary_PUSH_Municipality(struct zx_hrxml_LocationSummary_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Municipality->g;
  x->Municipality = z;
}

/* FUNC(zx_hrxml_LocationSummary_REV_Municipality) */

void zx_hrxml_LocationSummary_REV_Municipality(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Municipality;
  if (!y) return;
  x->Municipality = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Municipality->g;
    x->Municipality = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocationSummary_PUT_Municipality) */

void zx_hrxml_LocationSummary_PUT_Municipality(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Municipality;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Municipality = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LocationSummary_ADD_Municipality) */

void zx_hrxml_LocationSummary_ADD_Municipality(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Municipality->g;
    x->Municipality = z;
    return;
  case -1:
    y = x->Municipality;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LocationSummary_DEL_Municipality) */

void zx_hrxml_LocationSummary_DEL_Municipality(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Municipality = (struct zx_elem_s*)x->Municipality->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Municipality;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocationSummary_NUM_Region) */

int zx_hrxml_LocationSummary_NUM_Region(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Region; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocationSummary_GET_Region) */

struct zx_elem_s* zx_hrxml_LocationSummary_GET_Region(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Region; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_POP_Region) */

struct zx_elem_s* zx_hrxml_LocationSummary_POP_Region(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Region;
  if (y)
    x->Region = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_PUSH_Region) */

void zx_hrxml_LocationSummary_PUSH_Region(struct zx_hrxml_LocationSummary_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Region->g;
  x->Region = z;
}

/* FUNC(zx_hrxml_LocationSummary_REV_Region) */

void zx_hrxml_LocationSummary_REV_Region(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Region;
  if (!y) return;
  x->Region = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Region->g;
    x->Region = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocationSummary_PUT_Region) */

void zx_hrxml_LocationSummary_PUT_Region(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Region;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Region = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LocationSummary_ADD_Region) */

void zx_hrxml_LocationSummary_ADD_Region(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Region->g;
    x->Region = z;
    return;
  case -1:
    y = x->Region;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LocationSummary_DEL_Region) */

void zx_hrxml_LocationSummary_DEL_Region(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Region = (struct zx_elem_s*)x->Region->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Region;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocationSummary_NUM_CountryCode) */

int zx_hrxml_LocationSummary_NUM_CountryCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CountryCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocationSummary_GET_CountryCode) */

struct zx_elem_s* zx_hrxml_LocationSummary_GET_CountryCode(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CountryCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_POP_CountryCode) */

struct zx_elem_s* zx_hrxml_LocationSummary_POP_CountryCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CountryCode;
  if (y)
    x->CountryCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_PUSH_CountryCode) */

void zx_hrxml_LocationSummary_PUSH_CountryCode(struct zx_hrxml_LocationSummary_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CountryCode->g;
  x->CountryCode = z;
}

/* FUNC(zx_hrxml_LocationSummary_REV_CountryCode) */

void zx_hrxml_LocationSummary_REV_CountryCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CountryCode;
  if (!y) return;
  x->CountryCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CountryCode->g;
    x->CountryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocationSummary_PUT_CountryCode) */

void zx_hrxml_LocationSummary_PUT_CountryCode(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CountryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CountryCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LocationSummary_ADD_CountryCode) */

void zx_hrxml_LocationSummary_ADD_CountryCode(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CountryCode->g;
    x->CountryCode = z;
    return;
  case -1:
    y = x->CountryCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LocationSummary_DEL_CountryCode) */

void zx_hrxml_LocationSummary_DEL_CountryCode(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CountryCode = (struct zx_elem_s*)x->CountryCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CountryCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LocationSummary_NUM_PostalCode) */

int zx_hrxml_LocationSummary_NUM_PostalCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LocationSummary_GET_PostalCode) */

struct zx_elem_s* zx_hrxml_LocationSummary_GET_PostalCode(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PostalCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_POP_PostalCode) */

struct zx_elem_s* zx_hrxml_LocationSummary_POP_PostalCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PostalCode;
  if (y)
    x->PostalCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_LocationSummary_PUSH_PostalCode) */

void zx_hrxml_LocationSummary_PUSH_PostalCode(struct zx_hrxml_LocationSummary_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PostalCode->g;
  x->PostalCode = z;
}

/* FUNC(zx_hrxml_LocationSummary_REV_PostalCode) */

void zx_hrxml_LocationSummary_REV_PostalCode(struct zx_hrxml_LocationSummary_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PostalCode;
  if (!y) return;
  x->PostalCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PostalCode->g;
    x->PostalCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LocationSummary_PUT_PostalCode) */

void zx_hrxml_LocationSummary_PUT_PostalCode(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PostalCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PostalCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_LocationSummary_ADD_PostalCode) */

void zx_hrxml_LocationSummary_ADD_PostalCode(struct zx_hrxml_LocationSummary_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PostalCode->g;
    x->PostalCode = z;
    return;
  case -1:
    y = x->PostalCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_LocationSummary_DEL_PostalCode) */

void zx_hrxml_LocationSummary_DEL_PostalCode(struct zx_hrxml_LocationSummary_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalCode = (struct zx_elem_s*)x->PostalCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PostalCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif













#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LowestPossibleValue_NUM_NumericValue) */

int zx_hrxml_LowestPossibleValue_NUM_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumericValue; y; ++n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LowestPossibleValue_GET_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_LowestPossibleValue_GET_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  for (y = x->NumericValue; n>=0 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LowestPossibleValue_POP_NumericValue) */

struct zx_hrxml_NumericValue_s* zx_hrxml_LowestPossibleValue_POP_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return 0;
  y = x->NumericValue;
  if (y)
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LowestPossibleValue_PUSH_NumericValue) */

void zx_hrxml_LowestPossibleValue_PUSH_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x, struct zx_hrxml_NumericValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->NumericValue->gg.g;
  x->NumericValue = z;
}

/* FUNC(zx_hrxml_LowestPossibleValue_REV_NumericValue) */

void zx_hrxml_LowestPossibleValue_REV_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_NumericValue_s* nxt;
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  y = x->NumericValue;
  if (!y) return;
  x->NumericValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_NumericValue_s*)y->gg.g.n;
    y->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LowestPossibleValue_PUT_NumericValue) */

void zx_hrxml_LowestPossibleValue_PUT_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  y = x->NumericValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->NumericValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LowestPossibleValue_ADD_NumericValue) */

void zx_hrxml_LowestPossibleValue_ADD_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x, int n, struct zx_hrxml_NumericValue_s* z)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->NumericValue->gg.g;
    x->NumericValue = z;
    return;
  case -1:
    y = x->NumericValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LowestPossibleValue_DEL_NumericValue) */

void zx_hrxml_LowestPossibleValue_DEL_NumericValue(struct zx_hrxml_LowestPossibleValue_s* x, int n)
{
  struct zx_hrxml_NumericValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumericValue = (struct zx_hrxml_NumericValue_s*)x->NumericValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_NumericValue_s*)x->NumericValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NumericValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NumericValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_LowestPossibleValue_NUM_StringValue) */

int zx_hrxml_LowestPossibleValue_NUM_StringValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringValue; y; ++n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_LowestPossibleValue_GET_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_LowestPossibleValue_GET_StringValue(struct zx_hrxml_LowestPossibleValue_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  for (y = x->StringValue; n>=0 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_LowestPossibleValue_POP_StringValue) */

struct zx_hrxml_StringValue_s* zx_hrxml_LowestPossibleValue_POP_StringValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return 0;
  y = x->StringValue;
  if (y)
    x->StringValue = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_LowestPossibleValue_PUSH_StringValue) */

void zx_hrxml_LowestPossibleValue_PUSH_StringValue(struct zx_hrxml_LowestPossibleValue_s* x, struct zx_hrxml_StringValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StringValue->gg.g;
  x->StringValue = z;
}

/* FUNC(zx_hrxml_LowestPossibleValue_REV_StringValue) */

void zx_hrxml_LowestPossibleValue_REV_StringValue(struct zx_hrxml_LowestPossibleValue_s* x)
{
  struct zx_hrxml_StringValue_s* nxt;
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  y = x->StringValue;
  if (!y) return;
  x->StringValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_StringValue_s*)y->gg.g.n;
    y->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_LowestPossibleValue_PUT_StringValue) */

void zx_hrxml_LowestPossibleValue_PUT_StringValue(struct zx_hrxml_LowestPossibleValue_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  y = x->StringValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StringValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_LowestPossibleValue_ADD_StringValue) */

void zx_hrxml_LowestPossibleValue_ADD_StringValue(struct zx_hrxml_LowestPossibleValue_s* x, int n, struct zx_hrxml_StringValue_s* z)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StringValue->gg.g;
    x->StringValue = z;
    return;
  case -1:
    y = x->StringValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_LowestPossibleValue_DEL_StringValue) */

void zx_hrxml_LowestPossibleValue_DEL_StringValue(struct zx_hrxml_LowestPossibleValue_s* x, int n)
{
  struct zx_hrxml_StringValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringValue = (struct zx_hrxml_StringValue_s*)x->StringValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StringValue_s*)x->StringValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StringValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StringValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MatchedObjectId_NUM_IdValue) */

int zx_hrxml_MatchedObjectId_NUM_IdValue(struct zx_hrxml_MatchedObjectId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MatchedObjectId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_MatchedObjectId_GET_IdValue(struct zx_hrxml_MatchedObjectId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MatchedObjectId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_MatchedObjectId_POP_IdValue(struct zx_hrxml_MatchedObjectId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_MatchedObjectId_PUSH_IdValue) */

void zx_hrxml_MatchedObjectId_PUSH_IdValue(struct zx_hrxml_MatchedObjectId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_MatchedObjectId_REV_IdValue) */

void zx_hrxml_MatchedObjectId_REV_IdValue(struct zx_hrxml_MatchedObjectId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MatchedObjectId_PUT_IdValue) */

void zx_hrxml_MatchedObjectId_PUT_IdValue(struct zx_hrxml_MatchedObjectId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_MatchedObjectId_ADD_IdValue) */

void zx_hrxml_MatchedObjectId_ADD_IdValue(struct zx_hrxml_MatchedObjectId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_MatchedObjectId_DEL_IdValue) */

void zx_hrxml_MatchedObjectId_DEL_IdValue(struct zx_hrxml_MatchedObjectId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_MatchedObjectId_GET_idOwner) */
struct zx_str* zx_hrxml_MatchedObjectId_GET_idOwner(struct zx_hrxml_MatchedObjectId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_MatchedObjectId_PUT_idOwner) */
void zx_hrxml_MatchedObjectId_PUT_idOwner(struct zx_hrxml_MatchedObjectId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_MatchedObjectId_GET_validFrom) */
struct zx_str* zx_hrxml_MatchedObjectId_GET_validFrom(struct zx_hrxml_MatchedObjectId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_MatchedObjectId_PUT_validFrom) */
void zx_hrxml_MatchedObjectId_PUT_validFrom(struct zx_hrxml_MatchedObjectId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_MatchedObjectId_GET_validTo) */
struct zx_str* zx_hrxml_MatchedObjectId_GET_validTo(struct zx_hrxml_MatchedObjectId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_MatchedObjectId_PUT_validTo) */
void zx_hrxml_MatchedObjectId_PUT_validTo(struct zx_hrxml_MatchedObjectId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Measure_NUM_MeasureSystem) */

int zx_hrxml_Measure_NUM_MeasureSystem(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MeasureSystem; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Measure_GET_MeasureSystem) */

struct zx_elem_s* zx_hrxml_Measure_GET_MeasureSystem(struct zx_hrxml_Measure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MeasureSystem; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Measure_POP_MeasureSystem) */

struct zx_elem_s* zx_hrxml_Measure_POP_MeasureSystem(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MeasureSystem;
  if (y)
    x->MeasureSystem = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Measure_PUSH_MeasureSystem) */

void zx_hrxml_Measure_PUSH_MeasureSystem(struct zx_hrxml_Measure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MeasureSystem->g;
  x->MeasureSystem = z;
}

/* FUNC(zx_hrxml_Measure_REV_MeasureSystem) */

void zx_hrxml_Measure_REV_MeasureSystem(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MeasureSystem;
  if (!y) return;
  x->MeasureSystem = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MeasureSystem->g;
    x->MeasureSystem = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Measure_PUT_MeasureSystem) */

void zx_hrxml_Measure_PUT_MeasureSystem(struct zx_hrxml_Measure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MeasureSystem;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MeasureSystem = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Measure_ADD_MeasureSystem) */

void zx_hrxml_Measure_ADD_MeasureSystem(struct zx_hrxml_Measure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MeasureSystem->g;
    x->MeasureSystem = z;
    return;
  case -1:
    y = x->MeasureSystem;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureSystem; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Measure_DEL_MeasureSystem) */

void zx_hrxml_Measure_DEL_MeasureSystem(struct zx_hrxml_Measure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MeasureSystem = (struct zx_elem_s*)x->MeasureSystem->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MeasureSystem;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureSystem; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Measure_NUM_MeasureValue) */

int zx_hrxml_Measure_NUM_MeasureValue(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MeasureValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Measure_GET_MeasureValue) */

struct zx_elem_s* zx_hrxml_Measure_GET_MeasureValue(struct zx_hrxml_Measure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MeasureValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Measure_POP_MeasureValue) */

struct zx_elem_s* zx_hrxml_Measure_POP_MeasureValue(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MeasureValue;
  if (y)
    x->MeasureValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Measure_PUSH_MeasureValue) */

void zx_hrxml_Measure_PUSH_MeasureValue(struct zx_hrxml_Measure_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MeasureValue->g;
  x->MeasureValue = z;
}

/* FUNC(zx_hrxml_Measure_REV_MeasureValue) */

void zx_hrxml_Measure_REV_MeasureValue(struct zx_hrxml_Measure_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MeasureValue;
  if (!y) return;
  x->MeasureValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MeasureValue->g;
    x->MeasureValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Measure_PUT_MeasureValue) */

void zx_hrxml_Measure_PUT_MeasureValue(struct zx_hrxml_Measure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MeasureValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MeasureValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Measure_ADD_MeasureValue) */

void zx_hrxml_Measure_ADD_MeasureValue(struct zx_hrxml_Measure_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MeasureValue->g;
    x->MeasureValue = z;
    return;
  case -1:
    y = x->MeasureValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Measure_DEL_MeasureValue) */

void zx_hrxml_Measure_DEL_MeasureValue(struct zx_hrxml_Measure_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MeasureValue = (struct zx_elem_s*)x->MeasureValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MeasureValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MeasureValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Measure_GET_measureType) */
struct zx_str* zx_hrxml_Measure_GET_measureType(struct zx_hrxml_Measure_s* x) { return x->measureType; }
/* FUNC(zx_hrxml_Measure_PUT_measureType) */
void zx_hrxml_Measure_PUT_measureType(struct zx_hrxml_Measure_s* x, struct zx_str* y) { x->measureType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_CountryServed) */

int zx_hrxml_MilitaryHistory_NUM_CountryServed(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CountryServed; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_CountryServed) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_GET_CountryServed(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CountryServed; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_CountryServed) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_POP_CountryServed(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CountryServed;
  if (y)
    x->CountryServed = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_CountryServed) */

void zx_hrxml_MilitaryHistory_PUSH_CountryServed(struct zx_hrxml_MilitaryHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CountryServed->g;
  x->CountryServed = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_CountryServed) */

void zx_hrxml_MilitaryHistory_REV_CountryServed(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CountryServed;
  if (!y) return;
  x->CountryServed = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CountryServed->g;
    x->CountryServed = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_CountryServed) */

void zx_hrxml_MilitaryHistory_PUT_CountryServed(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CountryServed;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CountryServed = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_CountryServed) */

void zx_hrxml_MilitaryHistory_ADD_CountryServed(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CountryServed->g;
    x->CountryServed = z;
    return;
  case -1:
    y = x->CountryServed;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryServed; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_CountryServed) */

void zx_hrxml_MilitaryHistory_DEL_CountryServed(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CountryServed = (struct zx_elem_s*)x->CountryServed->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CountryServed;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryServed; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_ServiceNumber) */

int zx_hrxml_MilitaryHistory_NUM_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceNumber_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ServiceNumber; y; ++n, y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_ServiceNumber) */

struct zx_hrxml_ServiceNumber_s* zx_hrxml_MilitaryHistory_GET_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x) return 0;
  for (y = x->ServiceNumber; n>=0 && y; --n, y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_ServiceNumber) */

struct zx_hrxml_ServiceNumber_s* zx_hrxml_MilitaryHistory_POP_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x) return 0;
  y = x->ServiceNumber;
  if (y)
    x->ServiceNumber = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_ServiceNumber) */

void zx_hrxml_MilitaryHistory_PUSH_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x, struct zx_hrxml_ServiceNumber_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ServiceNumber->gg.g;
  x->ServiceNumber = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_ServiceNumber) */

void zx_hrxml_MilitaryHistory_REV_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceNumber_s* nxt;
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x) return;
  y = x->ServiceNumber;
  if (!y) return;
  x->ServiceNumber = 0;
  while (y) {
    nxt = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n;
    y->gg.g.n = &x->ServiceNumber->gg.g;
    x->ServiceNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_ServiceNumber) */

void zx_hrxml_MilitaryHistory_PUT_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_ServiceNumber_s* z)
{
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x || !z) return;
  y = x->ServiceNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ServiceNumber = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_ServiceNumber) */

void zx_hrxml_MilitaryHistory_ADD_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_ServiceNumber_s* z)
{
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ServiceNumber->gg.g;
    x->ServiceNumber = z;
    return;
  case -1:
    y = x->ServiceNumber;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ServiceNumber; n > 1 && y; --n, y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_ServiceNumber) */

void zx_hrxml_MilitaryHistory_DEL_ServiceNumber(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_ServiceNumber_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ServiceNumber = (struct zx_hrxml_ServiceNumber_s*)x->ServiceNumber->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ServiceNumber_s*)x->ServiceNumber;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ServiceNumber; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ServiceNumber_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_ServiceDetail) */

int zx_hrxml_MilitaryHistory_NUM_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceDetail_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ServiceDetail; y; ++n, y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_ServiceDetail) */

struct zx_hrxml_ServiceDetail_s* zx_hrxml_MilitaryHistory_GET_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x) return 0;
  for (y = x->ServiceDetail; n>=0 && y; --n, y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_ServiceDetail) */

struct zx_hrxml_ServiceDetail_s* zx_hrxml_MilitaryHistory_POP_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x) return 0;
  y = x->ServiceDetail;
  if (y)
    x->ServiceDetail = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_ServiceDetail) */

void zx_hrxml_MilitaryHistory_PUSH_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x, struct zx_hrxml_ServiceDetail_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ServiceDetail->gg.g;
  x->ServiceDetail = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_ServiceDetail) */

void zx_hrxml_MilitaryHistory_REV_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_ServiceDetail_s* nxt;
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x) return;
  y = x->ServiceDetail;
  if (!y) return;
  x->ServiceDetail = 0;
  while (y) {
    nxt = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n;
    y->gg.g.n = &x->ServiceDetail->gg.g;
    x->ServiceDetail = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_ServiceDetail) */

void zx_hrxml_MilitaryHistory_PUT_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_ServiceDetail_s* z)
{
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x || !z) return;
  y = x->ServiceDetail;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ServiceDetail = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_ServiceDetail) */

void zx_hrxml_MilitaryHistory_ADD_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_ServiceDetail_s* z)
{
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ServiceDetail->gg.g;
    x->ServiceDetail = z;
    return;
  case -1:
    y = x->ServiceDetail;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ServiceDetail; n > 1 && y; --n, y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_ServiceDetail) */

void zx_hrxml_MilitaryHistory_DEL_ServiceDetail(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_ServiceDetail_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ServiceDetail = (struct zx_hrxml_ServiceDetail_s*)x->ServiceDetail->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ServiceDetail_s*)x->ServiceDetail;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ServiceDetail; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ServiceDetail_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_ServiceStatus) */

int zx_hrxml_MilitaryHistory_NUM_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ServiceStatus; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_ServiceStatus) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_GET_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ServiceStatus; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_ServiceStatus) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_POP_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ServiceStatus;
  if (y)
    x->ServiceStatus = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_ServiceStatus) */

void zx_hrxml_MilitaryHistory_PUSH_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ServiceStatus->g;
  x->ServiceStatus = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_ServiceStatus) */

void zx_hrxml_MilitaryHistory_REV_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ServiceStatus;
  if (!y) return;
  x->ServiceStatus = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ServiceStatus->g;
    x->ServiceStatus = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_ServiceStatus) */

void zx_hrxml_MilitaryHistory_PUT_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ServiceStatus;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ServiceStatus = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_ServiceStatus) */

void zx_hrxml_MilitaryHistory_ADD_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ServiceStatus->g;
    x->ServiceStatus = z;
    return;
  case -1:
    y = x->ServiceStatus;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ServiceStatus; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_ServiceStatus) */

void zx_hrxml_MilitaryHistory_DEL_ServiceStatus(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ServiceStatus = (struct zx_elem_s*)x->ServiceStatus->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ServiceStatus;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ServiceStatus; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_Comments) */

int zx_hrxml_MilitaryHistory_NUM_Comments(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_Comments) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_GET_Comments(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_Comments) */

struct zx_elem_s* zx_hrxml_MilitaryHistory_POP_Comments(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_Comments) */

void zx_hrxml_MilitaryHistory_PUSH_Comments(struct zx_hrxml_MilitaryHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_Comments) */

void zx_hrxml_MilitaryHistory_REV_Comments(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_Comments) */

void zx_hrxml_MilitaryHistory_PUT_Comments(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_Comments) */

void zx_hrxml_MilitaryHistory_ADD_Comments(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_Comments) */

void zx_hrxml_MilitaryHistory_DEL_Comments(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MilitaryHistory_NUM_UserArea) */

int zx_hrxml_MilitaryHistory_NUM_UserArea(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MilitaryHistory_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_MilitaryHistory_GET_UserArea(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_MilitaryHistory_POP_UserArea(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_MilitaryHistory_PUSH_UserArea) */

void zx_hrxml_MilitaryHistory_PUSH_UserArea(struct zx_hrxml_MilitaryHistory_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_MilitaryHistory_REV_UserArea) */

void zx_hrxml_MilitaryHistory_REV_UserArea(struct zx_hrxml_MilitaryHistory_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_PUT_UserArea) */

void zx_hrxml_MilitaryHistory_PUT_UserArea(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_MilitaryHistory_ADD_UserArea) */

void zx_hrxml_MilitaryHistory_ADD_UserArea(struct zx_hrxml_MilitaryHistory_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_MilitaryHistory_DEL_UserArea) */

void zx_hrxml_MilitaryHistory_DEL_UserArea(struct zx_hrxml_MilitaryHistory_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_MilitaryStatus_GET_type) */
struct zx_str* zx_hrxml_MilitaryStatus_GET_type(struct zx_hrxml_MilitaryStatus_s* x) { return x->type; }
/* FUNC(zx_hrxml_MilitaryStatus_PUT_type) */
void zx_hrxml_MilitaryStatus_PUT_type(struct zx_hrxml_MilitaryStatus_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Mobile_NUM_FormattedNumber) */

int zx_hrxml_Mobile_NUM_FormattedNumber(struct zx_hrxml_Mobile_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Mobile_GET_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Mobile_GET_FormattedNumber(struct zx_hrxml_Mobile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Mobile_POP_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Mobile_POP_FormattedNumber(struct zx_hrxml_Mobile_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedNumber;
  if (y)
    x->FormattedNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Mobile_PUSH_FormattedNumber) */

void zx_hrxml_Mobile_PUSH_FormattedNumber(struct zx_hrxml_Mobile_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedNumber->g;
  x->FormattedNumber = z;
}

/* FUNC(zx_hrxml_Mobile_REV_FormattedNumber) */

void zx_hrxml_Mobile_REV_FormattedNumber(struct zx_hrxml_Mobile_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedNumber;
  if (!y) return;
  x->FormattedNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Mobile_PUT_FormattedNumber) */

void zx_hrxml_Mobile_PUT_FormattedNumber(struct zx_hrxml_Mobile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Mobile_ADD_FormattedNumber) */

void zx_hrxml_Mobile_ADD_FormattedNumber(struct zx_hrxml_Mobile_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = z;
    return;
  case -1:
    y = x->FormattedNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Mobile_DEL_FormattedNumber) */

void zx_hrxml_Mobile_DEL_FormattedNumber(struct zx_hrxml_Mobile_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedNumber = (struct zx_elem_s*)x->FormattedNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Mobile_GET_smsEnabled) */
struct zx_str* zx_hrxml_Mobile_GET_smsEnabled(struct zx_hrxml_Mobile_s* x) { return x->smsEnabled; }
/* FUNC(zx_hrxml_Mobile_PUT_smsEnabled) */
void zx_hrxml_Mobile_PUT_smsEnabled(struct zx_hrxml_Mobile_s* x, struct zx_str* y) { x->smsEnabled = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MostRecentDate_NUM_AnyDate) */

int zx_hrxml_MostRecentDate_NUM_AnyDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MostRecentDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_MostRecentDate_GET_AnyDate(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_MostRecentDate_POP_AnyDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_PUSH_AnyDate) */

void zx_hrxml_MostRecentDate_PUSH_AnyDate(struct zx_hrxml_MostRecentDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_MostRecentDate_REV_AnyDate) */

void zx_hrxml_MostRecentDate_REV_AnyDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_PUT_AnyDate) */

void zx_hrxml_MostRecentDate_PUT_AnyDate(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_ADD_AnyDate) */

void zx_hrxml_MostRecentDate_ADD_AnyDate(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MostRecentDate_DEL_AnyDate) */

void zx_hrxml_MostRecentDate_DEL_AnyDate(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MostRecentDate_NUM_YearMonth) */

int zx_hrxml_MostRecentDate_NUM_YearMonth(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MostRecentDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_MostRecentDate_GET_YearMonth(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_MostRecentDate_POP_YearMonth(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_PUSH_YearMonth) */

void zx_hrxml_MostRecentDate_PUSH_YearMonth(struct zx_hrxml_MostRecentDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_MostRecentDate_REV_YearMonth) */

void zx_hrxml_MostRecentDate_REV_YearMonth(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_PUT_YearMonth) */

void zx_hrxml_MostRecentDate_PUT_YearMonth(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_ADD_YearMonth) */

void zx_hrxml_MostRecentDate_ADD_YearMonth(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MostRecentDate_DEL_YearMonth) */

void zx_hrxml_MostRecentDate_DEL_YearMonth(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MostRecentDate_NUM_Year) */

int zx_hrxml_MostRecentDate_NUM_Year(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MostRecentDate_GET_Year) */

struct zx_elem_s* zx_hrxml_MostRecentDate_GET_Year(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_POP_Year) */

struct zx_elem_s* zx_hrxml_MostRecentDate_POP_Year(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_PUSH_Year) */

void zx_hrxml_MostRecentDate_PUSH_Year(struct zx_hrxml_MostRecentDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_MostRecentDate_REV_Year) */

void zx_hrxml_MostRecentDate_REV_Year(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_PUT_Year) */

void zx_hrxml_MostRecentDate_PUT_Year(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_ADD_Year) */

void zx_hrxml_MostRecentDate_ADD_Year(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MostRecentDate_DEL_Year) */

void zx_hrxml_MostRecentDate_DEL_Year(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MostRecentDate_NUM_MonthDay) */

int zx_hrxml_MostRecentDate_NUM_MonthDay(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MostRecentDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_MostRecentDate_GET_MonthDay(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_MostRecentDate_POP_MonthDay(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_PUSH_MonthDay) */

void zx_hrxml_MostRecentDate_PUSH_MonthDay(struct zx_hrxml_MostRecentDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_MostRecentDate_REV_MonthDay) */

void zx_hrxml_MostRecentDate_REV_MonthDay(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_PUT_MonthDay) */

void zx_hrxml_MostRecentDate_PUT_MonthDay(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_ADD_MonthDay) */

void zx_hrxml_MostRecentDate_ADD_MonthDay(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MostRecentDate_DEL_MonthDay) */

void zx_hrxml_MostRecentDate_DEL_MonthDay(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_MostRecentDate_NUM_StringDate) */

int zx_hrxml_MostRecentDate_NUM_StringDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_MostRecentDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_MostRecentDate_GET_StringDate(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_MostRecentDate_POP_StringDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_MostRecentDate_PUSH_StringDate) */

void zx_hrxml_MostRecentDate_PUSH_StringDate(struct zx_hrxml_MostRecentDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_MostRecentDate_REV_StringDate) */

void zx_hrxml_MostRecentDate_REV_StringDate(struct zx_hrxml_MostRecentDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_PUT_StringDate) */

void zx_hrxml_MostRecentDate_PUT_StringDate(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_MostRecentDate_ADD_StringDate) */

void zx_hrxml_MostRecentDate_ADD_StringDate(struct zx_hrxml_MostRecentDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_MostRecentDate_DEL_StringDate) */

void zx_hrxml_MostRecentDate_DEL_StringDate(struct zx_hrxml_MostRecentDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_MostRecentDate_GET_dateDescription) */
struct zx_str* zx_hrxml_MostRecentDate_GET_dateDescription(struct zx_hrxml_MostRecentDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_MostRecentDate_PUT_dateDescription) */
void zx_hrxml_MostRecentDate_PUT_dateDescription(struct zx_hrxml_MostRecentDate_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_NonXMLResume_NUM_TextResume) */

int zx_hrxml_NonXMLResume_NUM_TextResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TextResume; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_NonXMLResume_GET_TextResume) */

struct zx_elem_s* zx_hrxml_NonXMLResume_GET_TextResume(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->TextResume; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_POP_TextResume) */

struct zx_elem_s* zx_hrxml_NonXMLResume_POP_TextResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->TextResume;
  if (y)
    x->TextResume = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_PUSH_TextResume) */

void zx_hrxml_NonXMLResume_PUSH_TextResume(struct zx_hrxml_NonXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->TextResume->g;
  x->TextResume = z;
}

/* FUNC(zx_hrxml_NonXMLResume_REV_TextResume) */

void zx_hrxml_NonXMLResume_REV_TextResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->TextResume;
  if (!y) return;
  x->TextResume = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->TextResume->g;
    x->TextResume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_PUT_TextResume) */

void zx_hrxml_NonXMLResume_PUT_TextResume(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->TextResume;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->TextResume = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_ADD_TextResume) */

void zx_hrxml_NonXMLResume_ADD_TextResume(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->TextResume->g;
    x->TextResume = z;
    return;
  case -1:
    y = x->TextResume;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TextResume; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_NonXMLResume_DEL_TextResume) */

void zx_hrxml_NonXMLResume_DEL_TextResume(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TextResume = (struct zx_elem_s*)x->TextResume->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->TextResume;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TextResume; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_NonXMLResume_NUM_LinkToResume) */

int zx_hrxml_NonXMLResume_NUM_LinkToResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LinkToResume; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_NonXMLResume_GET_LinkToResume) */

struct zx_elem_s* zx_hrxml_NonXMLResume_GET_LinkToResume(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->LinkToResume; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_POP_LinkToResume) */

struct zx_elem_s* zx_hrxml_NonXMLResume_POP_LinkToResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->LinkToResume;
  if (y)
    x->LinkToResume = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_PUSH_LinkToResume) */

void zx_hrxml_NonXMLResume_PUSH_LinkToResume(struct zx_hrxml_NonXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->LinkToResume->g;
  x->LinkToResume = z;
}

/* FUNC(zx_hrxml_NonXMLResume_REV_LinkToResume) */

void zx_hrxml_NonXMLResume_REV_LinkToResume(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->LinkToResume;
  if (!y) return;
  x->LinkToResume = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->LinkToResume->g;
    x->LinkToResume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_PUT_LinkToResume) */

void zx_hrxml_NonXMLResume_PUT_LinkToResume(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->LinkToResume;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->LinkToResume = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_ADD_LinkToResume) */

void zx_hrxml_NonXMLResume_ADD_LinkToResume(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->LinkToResume->g;
    x->LinkToResume = z;
    return;
  case -1:
    y = x->LinkToResume;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LinkToResume; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_NonXMLResume_DEL_LinkToResume) */

void zx_hrxml_NonXMLResume_DEL_LinkToResume(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LinkToResume = (struct zx_elem_s*)x->LinkToResume->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->LinkToResume;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LinkToResume; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_NonXMLResume_NUM_SupportingMaterials) */

int zx_hrxml_NonXMLResume_NUM_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingMaterials; y; ++n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_NonXMLResume_GET_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_NonXMLResume_GET_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  for (y = x->SupportingMaterials; n>=0 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_POP_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_NonXMLResume_POP_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  y = x->SupportingMaterials;
  if (y)
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_PUSH_SupportingMaterials) */

void zx_hrxml_NonXMLResume_PUSH_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x, struct zx_hrxml_SupportingMaterials_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SupportingMaterials->gg.g;
  x->SupportingMaterials = z;
}

/* FUNC(zx_hrxml_NonXMLResume_REV_SupportingMaterials) */

void zx_hrxml_NonXMLResume_REV_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* nxt;
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  y = x->SupportingMaterials;
  if (!y) return;
  x->SupportingMaterials = 0;
  while (y) {
    nxt = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
    y->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_PUT_SupportingMaterials) */

void zx_hrxml_NonXMLResume_PUT_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  y = x->SupportingMaterials;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SupportingMaterials = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_ADD_SupportingMaterials) */

void zx_hrxml_NonXMLResume_ADD_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = z;
    return;
  case -1:
    y = x->SupportingMaterials;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_NonXMLResume_DEL_SupportingMaterials) */

void zx_hrxml_NonXMLResume_DEL_SupportingMaterials(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_NonXMLResume_NUM_Comments) */

int zx_hrxml_NonXMLResume_NUM_Comments(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_NonXMLResume_GET_Comments) */

struct zx_elem_s* zx_hrxml_NonXMLResume_GET_Comments(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_POP_Comments) */

struct zx_elem_s* zx_hrxml_NonXMLResume_POP_Comments(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_PUSH_Comments) */

void zx_hrxml_NonXMLResume_PUSH_Comments(struct zx_hrxml_NonXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_NonXMLResume_REV_Comments) */

void zx_hrxml_NonXMLResume_REV_Comments(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_PUT_Comments) */

void zx_hrxml_NonXMLResume_PUT_Comments(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_ADD_Comments) */

void zx_hrxml_NonXMLResume_ADD_Comments(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_NonXMLResume_DEL_Comments) */

void zx_hrxml_NonXMLResume_DEL_Comments(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_NonXMLResume_NUM_RevisionDate) */

int zx_hrxml_NonXMLResume_NUM_RevisionDate(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RevisionDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_NonXMLResume_GET_RevisionDate) */

struct zx_elem_s* zx_hrxml_NonXMLResume_GET_RevisionDate(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->RevisionDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_POP_RevisionDate) */

struct zx_elem_s* zx_hrxml_NonXMLResume_POP_RevisionDate(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->RevisionDate;
  if (y)
    x->RevisionDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_NonXMLResume_PUSH_RevisionDate) */

void zx_hrxml_NonXMLResume_PUSH_RevisionDate(struct zx_hrxml_NonXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->RevisionDate->g;
  x->RevisionDate = z;
}

/* FUNC(zx_hrxml_NonXMLResume_REV_RevisionDate) */

void zx_hrxml_NonXMLResume_REV_RevisionDate(struct zx_hrxml_NonXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->RevisionDate;
  if (!y) return;
  x->RevisionDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->RevisionDate->g;
    x->RevisionDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_PUT_RevisionDate) */

void zx_hrxml_NonXMLResume_PUT_RevisionDate(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->RevisionDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->RevisionDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_NonXMLResume_ADD_RevisionDate) */

void zx_hrxml_NonXMLResume_ADD_RevisionDate(struct zx_hrxml_NonXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->RevisionDate->g;
    x->RevisionDate = z;
    return;
  case -1:
    y = x->RevisionDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RevisionDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_NonXMLResume_DEL_RevisionDate) */

void zx_hrxml_NonXMLResume_DEL_RevisionDate(struct zx_hrxml_NonXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RevisionDate = (struct zx_elem_s*)x->RevisionDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->RevisionDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RevisionDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_NumericValue_GET_description) */
struct zx_str* zx_hrxml_NumericValue_GET_description(struct zx_hrxml_NumericValue_s* x) { return x->description; }
/* FUNC(zx_hrxml_NumericValue_PUT_description) */
void zx_hrxml_NumericValue_PUT_description(struct zx_hrxml_NumericValue_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_NumericValue_GET_interval) */
struct zx_str* zx_hrxml_NumericValue_GET_interval(struct zx_hrxml_NumericValue_s* x) { return x->interval; }
/* FUNC(zx_hrxml_NumericValue_PUT_interval) */
void zx_hrxml_NumericValue_PUT_interval(struct zx_hrxml_NumericValue_s* x, struct zx_str* y) { x->interval = y; }
/* FUNC(zx_hrxml_NumericValue_GET_maxValue) */
struct zx_str* zx_hrxml_NumericValue_GET_maxValue(struct zx_hrxml_NumericValue_s* x) { return x->maxValue; }
/* FUNC(zx_hrxml_NumericValue_PUT_maxValue) */
void zx_hrxml_NumericValue_PUT_maxValue(struct zx_hrxml_NumericValue_s* x, struct zx_str* y) { x->maxValue = y; }
/* FUNC(zx_hrxml_NumericValue_GET_minValue) */
struct zx_str* zx_hrxml_NumericValue_GET_minValue(struct zx_hrxml_NumericValue_s* x) { return x->minValue; }
/* FUNC(zx_hrxml_NumericValue_PUT_minValue) */
void zx_hrxml_NumericValue_PUT_minValue(struct zx_hrxml_NumericValue_s* x, struct zx_str* y) { x->minValue = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgIndustry_NUM_IndustryDescription) */

int zx_hrxml_OrgIndustry_NUM_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryDescription; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgIndustry_GET_IndustryDescription) */

struct zx_elem_s* zx_hrxml_OrgIndustry_GET_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->IndustryDescription; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgIndustry_POP_IndustryDescription) */

struct zx_elem_s* zx_hrxml_OrgIndustry_POP_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->IndustryDescription;
  if (y)
    x->IndustryDescription = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgIndustry_PUSH_IndustryDescription) */

void zx_hrxml_OrgIndustry_PUSH_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->IndustryDescription->g;
  x->IndustryDescription = z;
}

/* FUNC(zx_hrxml_OrgIndustry_REV_IndustryDescription) */

void zx_hrxml_OrgIndustry_REV_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->IndustryDescription;
  if (!y) return;
  x->IndustryDescription = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->IndustryDescription->g;
    x->IndustryDescription = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgIndustry_PUT_IndustryDescription) */

void zx_hrxml_OrgIndustry_PUT_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->IndustryDescription;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->IndustryDescription = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OrgIndustry_ADD_IndustryDescription) */

void zx_hrxml_OrgIndustry_ADD_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->IndustryDescription->g;
    x->IndustryDescription = z;
    return;
  case -1:
    y = x->IndustryDescription;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IndustryDescription; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OrgIndustry_DEL_IndustryDescription) */

void zx_hrxml_OrgIndustry_DEL_IndustryDescription(struct zx_hrxml_OrgIndustry_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryDescription = (struct zx_elem_s*)x->IndustryDescription->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->IndustryDescription;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IndustryDescription; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgIndustry_NUM_IndustryCode) */

int zx_hrxml_OrgIndustry_NUM_IndustryCode(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgIndustry_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_OrgIndustry_GET_IndustryCode(struct zx_hrxml_OrgIndustry_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgIndustry_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_OrgIndustry_POP_IndustryCode(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgIndustry_PUSH_IndustryCode) */

void zx_hrxml_OrgIndustry_PUSH_IndustryCode(struct zx_hrxml_OrgIndustry_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_OrgIndustry_REV_IndustryCode) */

void zx_hrxml_OrgIndustry_REV_IndustryCode(struct zx_hrxml_OrgIndustry_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgIndustry_PUT_IndustryCode) */

void zx_hrxml_OrgIndustry_PUT_IndustryCode(struct zx_hrxml_OrgIndustry_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrgIndustry_ADD_IndustryCode) */

void zx_hrxml_OrgIndustry_ADD_IndustryCode(struct zx_hrxml_OrgIndustry_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrgIndustry_DEL_IndustryCode) */

void zx_hrxml_OrgIndustry_DEL_IndustryCode(struct zx_hrxml_OrgIndustry_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_OrgIndustry_GET_primaryIndicator) */
struct zx_str* zx_hrxml_OrgIndustry_GET_primaryIndicator(struct zx_hrxml_OrgIndustry_s* x) { return x->primaryIndicator; }
/* FUNC(zx_hrxml_OrgIndustry_PUT_primaryIndicator) */
void zx_hrxml_OrgIndustry_PUT_primaryIndicator(struct zx_hrxml_OrgIndustry_s* x, struct zx_str* y) { x->primaryIndicator = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgInfo_NUM_PositionLocation) */

int zx_hrxml_OrgInfo_NUM_PositionLocation(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_PositionLocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionLocation; y; ++n, y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgInfo_GET_PositionLocation) */

struct zx_hrxml_PositionLocation_s* zx_hrxml_OrgInfo_GET_PositionLocation(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_hrxml_PositionLocation_s* y;
  if (!x) return 0;
  for (y = x->PositionLocation; n>=0 && y; --n, y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_POP_PositionLocation) */

struct zx_hrxml_PositionLocation_s* zx_hrxml_OrgInfo_POP_PositionLocation(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_PositionLocation_s* y;
  if (!x) return 0;
  y = x->PositionLocation;
  if (y)
    x->PositionLocation = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_PUSH_PositionLocation) */

void zx_hrxml_OrgInfo_PUSH_PositionLocation(struct zx_hrxml_OrgInfo_s* x, struct zx_hrxml_PositionLocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PositionLocation->gg.g;
  x->PositionLocation = z;
}

/* FUNC(zx_hrxml_OrgInfo_REV_PositionLocation) */

void zx_hrxml_OrgInfo_REV_PositionLocation(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_PositionLocation_s* nxt;
  struct zx_hrxml_PositionLocation_s* y;
  if (!x) return;
  y = x->PositionLocation;
  if (!y) return;
  x->PositionLocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n;
    y->gg.g.n = &x->PositionLocation->gg.g;
    x->PositionLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgInfo_PUT_PositionLocation) */

void zx_hrxml_OrgInfo_PUT_PositionLocation(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_hrxml_PositionLocation_s* z)
{
  struct zx_hrxml_PositionLocation_s* y;
  if (!x || !z) return;
  y = x->PositionLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PositionLocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrgInfo_ADD_PositionLocation) */

void zx_hrxml_OrgInfo_ADD_PositionLocation(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_hrxml_PositionLocation_s* z)
{
  struct zx_hrxml_PositionLocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PositionLocation->gg.g;
    x->PositionLocation = z;
    return;
  case -1:
    y = x->PositionLocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionLocation; n > 1 && y; --n, y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrgInfo_DEL_PositionLocation) */

void zx_hrxml_OrgInfo_DEL_PositionLocation(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_hrxml_PositionLocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionLocation = (struct zx_hrxml_PositionLocation_s*)x->PositionLocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PositionLocation_s*)x->PositionLocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionLocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgInfo_NUM_WebSite) */

int zx_hrxml_OrgInfo_NUM_WebSite(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WebSite; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgInfo_GET_WebSite) */

struct zx_elem_s* zx_hrxml_OrgInfo_GET_WebSite(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->WebSite; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_POP_WebSite) */

struct zx_elem_s* zx_hrxml_OrgInfo_POP_WebSite(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->WebSite;
  if (y)
    x->WebSite = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_PUSH_WebSite) */

void zx_hrxml_OrgInfo_PUSH_WebSite(struct zx_hrxml_OrgInfo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->WebSite->g;
  x->WebSite = z;
}

/* FUNC(zx_hrxml_OrgInfo_REV_WebSite) */

void zx_hrxml_OrgInfo_REV_WebSite(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->WebSite;
  if (!y) return;
  x->WebSite = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->WebSite->g;
    x->WebSite = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgInfo_PUT_WebSite) */

void zx_hrxml_OrgInfo_PUT_WebSite(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->WebSite;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->WebSite = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OrgInfo_ADD_WebSite) */

void zx_hrxml_OrgInfo_ADD_WebSite(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->WebSite->g;
    x->WebSite = z;
    return;
  case -1:
    y = x->WebSite;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WebSite; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OrgInfo_DEL_WebSite) */

void zx_hrxml_OrgInfo_DEL_WebSite(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WebSite = (struct zx_elem_s*)x->WebSite->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->WebSite;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WebSite; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgInfo_NUM_LocationSummary) */

int zx_hrxml_OrgInfo_NUM_LocationSummary(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LocationSummary; y; ++n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgInfo_GET_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_OrgInfo_GET_LocationSummary(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  for (y = x->LocationSummary; n>=0 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_POP_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_OrgInfo_POP_LocationSummary(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  y = x->LocationSummary;
  if (y)
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgInfo_PUSH_LocationSummary) */

void zx_hrxml_OrgInfo_PUSH_LocationSummary(struct zx_hrxml_OrgInfo_s* x, struct zx_hrxml_LocationSummary_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LocationSummary->gg.g;
  x->LocationSummary = z;
}

/* FUNC(zx_hrxml_OrgInfo_REV_LocationSummary) */

void zx_hrxml_OrgInfo_REV_LocationSummary(struct zx_hrxml_OrgInfo_s* x)
{
  struct zx_hrxml_LocationSummary_s* nxt;
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  y = x->LocationSummary;
  if (!y) return;
  x->LocationSummary = 0;
  while (y) {
    nxt = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
    y->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgInfo_PUT_LocationSummary) */

void zx_hrxml_OrgInfo_PUT_LocationSummary(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  y = x->LocationSummary;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LocationSummary = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrgInfo_ADD_LocationSummary) */

void zx_hrxml_OrgInfo_ADD_LocationSummary(struct zx_hrxml_OrgInfo_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = z;
    return;
  case -1:
    y = x->LocationSummary;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrgInfo_DEL_LocationSummary) */

void zx_hrxml_OrgInfo_DEL_LocationSummary(struct zx_hrxml_OrgInfo_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgName_NUM_OrganizationName) */

int zx_hrxml_OrgName_NUM_OrganizationName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgName_GET_OrganizationName) */

struct zx_elem_s* zx_hrxml_OrgName_GET_OrganizationName(struct zx_hrxml_OrgName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrganizationName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgName_POP_OrganizationName) */

struct zx_elem_s* zx_hrxml_OrgName_POP_OrganizationName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrganizationName;
  if (y)
    x->OrganizationName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgName_PUSH_OrganizationName) */

void zx_hrxml_OrgName_PUSH_OrganizationName(struct zx_hrxml_OrgName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrganizationName->g;
  x->OrganizationName = z;
}

/* FUNC(zx_hrxml_OrgName_REV_OrganizationName) */

void zx_hrxml_OrgName_REV_OrganizationName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrganizationName;
  if (!y) return;
  x->OrganizationName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrganizationName->g;
    x->OrganizationName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgName_PUT_OrganizationName) */

void zx_hrxml_OrgName_PUT_OrganizationName(struct zx_hrxml_OrgName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrganizationName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrganizationName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OrgName_ADD_OrganizationName) */

void zx_hrxml_OrgName_ADD_OrganizationName(struct zx_hrxml_OrgName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrganizationName->g;
    x->OrganizationName = z;
    return;
  case -1:
    y = x->OrganizationName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OrgName_DEL_OrganizationName) */

void zx_hrxml_OrgName_DEL_OrganizationName(struct zx_hrxml_OrgName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationName = (struct zx_elem_s*)x->OrganizationName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrganizationName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrgName_NUM_OrgName) */

int zx_hrxml_OrgName_NUM_OrgName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_hrxml_OrgName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrgName; y; ++n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrgName_GET_OrgName) */

struct zx_hrxml_OrgName_s* zx_hrxml_OrgName_GET_OrgName(struct zx_hrxml_OrgName_s* x, int n)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return 0;
  for (y = x->OrgName; n>=0 && y; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrgName_POP_OrgName) */

struct zx_hrxml_OrgName_s* zx_hrxml_OrgName_POP_OrgName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return 0;
  y = x->OrgName;
  if (y)
    x->OrgName = (struct zx_hrxml_OrgName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrgName_PUSH_OrgName) */

void zx_hrxml_OrgName_PUSH_OrgName(struct zx_hrxml_OrgName_s* x, struct zx_hrxml_OrgName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrgName->gg.g;
  x->OrgName = z;
}

/* FUNC(zx_hrxml_OrgName_REV_OrgName) */

void zx_hrxml_OrgName_REV_OrgName(struct zx_hrxml_OrgName_s* x)
{
  struct zx_hrxml_OrgName_s* nxt;
  struct zx_hrxml_OrgName_s* y;
  if (!x) return;
  y = x->OrgName;
  if (!y) return;
  x->OrgName = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrgName_s*)y->gg.g.n;
    y->gg.g.n = &x->OrgName->gg.g;
    x->OrgName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrgName_PUT_OrgName) */

void zx_hrxml_OrgName_PUT_OrgName(struct zx_hrxml_OrgName_s* x, int n, struct zx_hrxml_OrgName_s* z)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x || !z) return;
  y = x->OrgName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrgName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrgName_ADD_OrgName) */

void zx_hrxml_OrgName_ADD_OrgName(struct zx_hrxml_OrgName_s* x, int n, struct zx_hrxml_OrgName_s* z)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrgName->gg.g;
    x->OrgName = z;
    return;
  case -1:
    y = x->OrgName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgName; n > 1 && y; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrgName_DEL_OrgName) */

void zx_hrxml_OrgName_DEL_OrgName(struct zx_hrxml_OrgName_s* x, int n)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrgName = (struct zx_hrxml_OrgName_s*)x->OrgName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrgName_s*)x->OrgName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_OrgName_GET_organizationType) */
struct zx_str* zx_hrxml_OrgName_GET_organizationType(struct zx_hrxml_OrgName_s* x) { return x->organizationType; }
/* FUNC(zx_hrxml_OrgName_PUT_organizationType) */
void zx_hrxml_OrgName_PUT_organizationType(struct zx_hrxml_OrgName_s* x, struct zx_str* y) { x->organizationType = y; }












#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationId_NUM_IdValue) */

int zx_hrxml_OrganizationId_NUM_IdValue(struct zx_hrxml_OrganizationId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_OrganizationId_GET_IdValue(struct zx_hrxml_OrganizationId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_OrganizationId_POP_IdValue(struct zx_hrxml_OrganizationId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationId_PUSH_IdValue) */

void zx_hrxml_OrganizationId_PUSH_IdValue(struct zx_hrxml_OrganizationId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_OrganizationId_REV_IdValue) */

void zx_hrxml_OrganizationId_REV_IdValue(struct zx_hrxml_OrganizationId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationId_PUT_IdValue) */

void zx_hrxml_OrganizationId_PUT_IdValue(struct zx_hrxml_OrganizationId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationId_ADD_IdValue) */

void zx_hrxml_OrganizationId_ADD_IdValue(struct zx_hrxml_OrganizationId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationId_DEL_IdValue) */

void zx_hrxml_OrganizationId_DEL_IdValue(struct zx_hrxml_OrganizationId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_OrganizationId_GET_idOwner) */
struct zx_str* zx_hrxml_OrganizationId_GET_idOwner(struct zx_hrxml_OrganizationId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_OrganizationId_PUT_idOwner) */
void zx_hrxml_OrganizationId_PUT_idOwner(struct zx_hrxml_OrganizationId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_OrganizationId_GET_validFrom) */
struct zx_str* zx_hrxml_OrganizationId_GET_validFrom(struct zx_hrxml_OrganizationId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_OrganizationId_PUT_validFrom) */
void zx_hrxml_OrganizationId_PUT_validFrom(struct zx_hrxml_OrganizationId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_OrganizationId_GET_validTo) */
struct zx_str* zx_hrxml_OrganizationId_GET_validTo(struct zx_hrxml_OrganizationId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_OrganizationId_PUT_validTo) */
void zx_hrxml_OrganizationId_PUT_validTo(struct zx_hrxml_OrganizationId_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_OrganizationUnit_GET_attendanceStatus) */
struct zx_str* zx_hrxml_OrganizationUnit_GET_attendanceStatus(struct zx_hrxml_OrganizationUnit_s* x) { return x->attendanceStatus; }
/* FUNC(zx_hrxml_OrganizationUnit_PUT_attendanceStatus) */
void zx_hrxml_OrganizationUnit_PUT_attendanceStatus(struct zx_hrxml_OrganizationUnit_s* x, struct zx_str* y) { x->attendanceStatus = y; }
/* FUNC(zx_hrxml_OrganizationUnit_GET_organizationType) */
struct zx_str* zx_hrxml_OrganizationUnit_GET_organizationType(struct zx_hrxml_OrganizationUnit_s* x) { return x->organizationType; }
/* FUNC(zx_hrxml_OrganizationUnit_PUT_organizationType) */
void zx_hrxml_OrganizationUnit_PUT_organizationType(struct zx_hrxml_OrganizationUnit_s* x, struct zx_str* y) { x->organizationType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_OrganizationalUnitName) */

int zx_hrxml_OrganizationalUnit_NUM_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationalUnitName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_OrganizationalUnitName) */

struct zx_elem_s* zx_hrxml_OrganizationalUnit_GET_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrganizationalUnitName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_OrganizationalUnitName) */

struct zx_elem_s* zx_hrxml_OrganizationalUnit_POP_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrganizationalUnitName;
  if (y)
    x->OrganizationalUnitName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_OrganizationalUnitName) */

void zx_hrxml_OrganizationalUnit_PUSH_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrganizationalUnitName->g;
  x->OrganizationalUnitName = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_OrganizationalUnitName) */

void zx_hrxml_OrganizationalUnit_REV_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrganizationalUnitName;
  if (!y) return;
  x->OrganizationalUnitName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrganizationalUnitName->g;
    x->OrganizationalUnitName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_OrganizationalUnitName) */

void zx_hrxml_OrganizationalUnit_PUT_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrganizationalUnitName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrganizationalUnitName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_OrganizationalUnitName) */

void zx_hrxml_OrganizationalUnit_ADD_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrganizationalUnitName->g;
    x->OrganizationalUnitName = z;
    return;
  case -1:
    y = x->OrganizationalUnitName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_OrganizationalUnitName) */

void zx_hrxml_OrganizationalUnit_DEL_OrganizationalUnitName(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationalUnitName = (struct zx_elem_s*)x->OrganizationalUnitName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrganizationalUnitName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_OrganizationalUnitId) */

int zx_hrxml_OrganizationalUnit_NUM_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationalUnitId; y; ++n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_OrganizationalUnitId) */

struct zx_hrxml_OrganizationalUnitId_s* zx_hrxml_OrganizationalUnit_GET_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return 0;
  for (y = x->OrganizationalUnitId; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_OrganizationalUnitId) */

struct zx_hrxml_OrganizationalUnitId_s* zx_hrxml_OrganizationalUnit_POP_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return 0;
  y = x->OrganizationalUnitId;
  if (y)
    x->OrganizationalUnitId = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_OrganizationalUnitId) */

void zx_hrxml_OrganizationalUnit_PUSH_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationalUnitId->gg.g;
  x->OrganizationalUnitId = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_OrganizationalUnitId) */

void zx_hrxml_OrganizationalUnit_REV_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* nxt;
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return;
  y = x->OrganizationalUnitId;
  if (!y) return;
  x->OrganizationalUnitId = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationalUnitId->gg.g;
    x->OrganizationalUnitId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_OrganizationalUnitId) */

void zx_hrxml_OrganizationalUnit_PUT_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x || !z) return;
  y = x->OrganizationalUnitId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationalUnitId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_OrganizationalUnitId) */

void zx_hrxml_OrganizationalUnit_ADD_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationalUnitId->gg.g;
    x->OrganizationalUnitId = z;
    return;
  case -1:
    y = x->OrganizationalUnitId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitId; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_OrganizationalUnitId) */

void zx_hrxml_OrganizationalUnit_DEL_OrganizationalUnitId(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationalUnitId = (struct zx_hrxml_OrganizationalUnitId_s*)x->OrganizationalUnitId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationalUnitId_s*)x->OrganizationalUnitId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_OrganizationId) */

int zx_hrxml_OrganizationalUnit_NUM_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationId; y; ++n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_OrganizationalUnit_GET_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  for (y = x->OrganizationId; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_OrganizationalUnit_POP_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  y = x->OrganizationId;
  if (y)
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_OrganizationId) */

void zx_hrxml_OrganizationalUnit_PUSH_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_OrganizationId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationId->gg.g;
  x->OrganizationId = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_OrganizationId) */

void zx_hrxml_OrganizationalUnit_REV_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* nxt;
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  y = x->OrganizationId;
  if (!y) return;
  x->OrganizationId = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_OrganizationId) */

void zx_hrxml_OrganizationalUnit_PUT_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  y = x->OrganizationId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_OrganizationId) */

void zx_hrxml_OrganizationalUnit_ADD_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = z;
    return;
  case -1:
    y = x->OrganizationId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_OrganizationId) */

void zx_hrxml_OrganizationalUnit_DEL_OrganizationId(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_Description) */

int zx_hrxml_OrganizationalUnit_NUM_Description(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_OrganizationalUnit_GET_Description(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_OrganizationalUnit_POP_Description(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_Description) */

void zx_hrxml_OrganizationalUnit_PUSH_Description(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_Description) */

void zx_hrxml_OrganizationalUnit_REV_Description(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_Description) */

void zx_hrxml_OrganizationalUnit_PUT_Description(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_Description) */

void zx_hrxml_OrganizationalUnit_ADD_Description(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_Description) */

void zx_hrxml_OrganizationalUnit_DEL_Description(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_IndustryCode) */

int zx_hrxml_OrganizationalUnit_NUM_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_OrganizationalUnit_GET_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_OrganizationalUnit_POP_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_IndustryCode) */

void zx_hrxml_OrganizationalUnit_PUSH_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_IndustryCode) */

void zx_hrxml_OrganizationalUnit_REV_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_IndustryCode) */

void zx_hrxml_OrganizationalUnit_PUT_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_IndustryCode) */

void zx_hrxml_OrganizationalUnit_ADD_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_IndustryCode) */

void zx_hrxml_OrganizationalUnit_DEL_IndustryCode(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_AccountingCode) */

int zx_hrxml_OrganizationalUnit_NUM_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AccountingCode; y; ++n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_AccountingCode) */

struct zx_hrxml_AccountingCode_s* zx_hrxml_OrganizationalUnit_GET_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return 0;
  for (y = x->AccountingCode; n>=0 && y; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_AccountingCode) */

struct zx_hrxml_AccountingCode_s* zx_hrxml_OrganizationalUnit_POP_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return 0;
  y = x->AccountingCode;
  if (y)
    x->AccountingCode = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_AccountingCode) */

void zx_hrxml_OrganizationalUnit_PUSH_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_AccountingCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AccountingCode->gg.g;
  x->AccountingCode = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_AccountingCode) */

void zx_hrxml_OrganizationalUnit_REV_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* nxt;
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return;
  y = x->AccountingCode;
  if (!y) return;
  x->AccountingCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n;
    y->gg.g.n = &x->AccountingCode->gg.g;
    x->AccountingCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_AccountingCode) */

void zx_hrxml_OrganizationalUnit_PUT_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_AccountingCode_s* z)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x || !z) return;
  y = x->AccountingCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AccountingCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_AccountingCode) */

void zx_hrxml_OrganizationalUnit_ADD_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_AccountingCode_s* z)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AccountingCode->gg.g;
    x->AccountingCode = z;
    return;
  case -1:
    y = x->AccountingCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AccountingCode; n > 1 && y; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_AccountingCode) */

void zx_hrxml_OrganizationalUnit_DEL_AccountingCode(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AccountingCode = (struct zx_hrxml_AccountingCode_s*)x->AccountingCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AccountingCode_s*)x->AccountingCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AccountingCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_WorkSite) */

int zx_hrxml_OrganizationalUnit_NUM_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSite; y; ++n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_OrganizationalUnit_GET_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  for (y = x->WorkSite; n>=0 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_OrganizationalUnit_POP_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  y = x->WorkSite;
  if (y)
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_WorkSite) */

void zx_hrxml_OrganizationalUnit_PUSH_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_WorkSite_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSite->gg.g;
  x->WorkSite = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_WorkSite) */

void zx_hrxml_OrganizationalUnit_REV_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* nxt;
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  y = x->WorkSite;
  if (!y) return;
  x->WorkSite = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_WorkSite) */

void zx_hrxml_OrganizationalUnit_PUT_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  y = x->WorkSite;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSite = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_WorkSite) */

void zx_hrxml_OrganizationalUnit_ADD_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = z;
    return;
  case -1:
    y = x->WorkSite;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_WorkSite) */

void zx_hrxml_OrganizationalUnit_DEL_WorkSite(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)x->WorkSite->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSite_s*)x->WorkSite;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_RelatedOrganizationalUnit) */

int zx_hrxml_OrganizationalUnit_NUM_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RelatedOrganizationalUnit; y; ++n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_RelatedOrganizationalUnit) */

struct zx_hrxml_RelatedOrganizationalUnit_s* zx_hrxml_OrganizationalUnit_GET_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return 0;
  for (y = x->RelatedOrganizationalUnit; n>=0 && y; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_RelatedOrganizationalUnit) */

struct zx_hrxml_RelatedOrganizationalUnit_s* zx_hrxml_OrganizationalUnit_POP_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return 0;
  y = x->RelatedOrganizationalUnit;
  if (y)
    x->RelatedOrganizationalUnit = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_RelatedOrganizationalUnit) */

void zx_hrxml_OrganizationalUnit_PUSH_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
  x->RelatedOrganizationalUnit = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_RelatedOrganizationalUnit) */

void zx_hrxml_OrganizationalUnit_REV_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* nxt;
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return;
  y = x->RelatedOrganizationalUnit;
  if (!y) return;
  x->RelatedOrganizationalUnit = 0;
  while (y) {
    nxt = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n;
    y->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
    x->RelatedOrganizationalUnit = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_RelatedOrganizationalUnit) */

void zx_hrxml_OrganizationalUnit_PUT_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x || !z) return;
  y = x->RelatedOrganizationalUnit;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RelatedOrganizationalUnit = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_RelatedOrganizationalUnit) */

void zx_hrxml_OrganizationalUnit_ADD_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
    x->RelatedOrganizationalUnit = z;
    return;
  case -1:
    y = x->RelatedOrganizationalUnit;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganizationalUnit; n > 1 && y; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_RelatedOrganizationalUnit) */

void zx_hrxml_OrganizationalUnit_DEL_RelatedOrganizationalUnit(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RelatedOrganizationalUnit = (struct zx_hrxml_RelatedOrganizationalUnit_s*)x->RelatedOrganizationalUnit->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)x->RelatedOrganizationalUnit;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganizationalUnit; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_PersonMember) */

int zx_hrxml_OrganizationalUnit_NUM_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonMember; y; ++n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_PersonMember) */

struct zx_hrxml_PersonMember_s* zx_hrxml_OrganizationalUnit_GET_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return 0;
  for (y = x->PersonMember; n>=0 && y; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_PersonMember) */

struct zx_hrxml_PersonMember_s* zx_hrxml_OrganizationalUnit_POP_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return 0;
  y = x->PersonMember;
  if (y)
    x->PersonMember = (struct zx_hrxml_PersonMember_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_PersonMember) */

void zx_hrxml_OrganizationalUnit_PUSH_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_PersonMember_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonMember->gg.g;
  x->PersonMember = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_PersonMember) */

void zx_hrxml_OrganizationalUnit_REV_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* nxt;
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return;
  y = x->PersonMember;
  if (!y) return;
  x->PersonMember = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonMember_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonMember->gg.g;
    x->PersonMember = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_PersonMember) */

void zx_hrxml_OrganizationalUnit_PUT_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_PersonMember_s* z)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x || !z) return;
  y = x->PersonMember;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonMember = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_PersonMember) */

void zx_hrxml_OrganizationalUnit_ADD_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_PersonMember_s* z)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonMember->gg.g;
    x->PersonMember = z;
    return;
  case -1:
    y = x->PersonMember;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonMember; n > 1 && y; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_PersonMember) */

void zx_hrxml_OrganizationalUnit_DEL_PersonMember(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonMember = (struct zx_hrxml_PersonMember_s*)x->PersonMember->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonMember_s*)x->PersonMember;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonMember; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnit_NUM_UserArea) */

int zx_hrxml_OrganizationalUnit_NUM_UserArea(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnit_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_OrganizationalUnit_GET_UserArea(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_OrganizationalUnit_POP_UserArea(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUSH_UserArea) */

void zx_hrxml_OrganizationalUnit_PUSH_UserArea(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_OrganizationalUnit_REV_UserArea) */

void zx_hrxml_OrganizationalUnit_REV_UserArea(struct zx_hrxml_OrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_PUT_UserArea) */

void zx_hrxml_OrganizationalUnit_PUT_UserArea(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnit_ADD_UserArea) */

void zx_hrxml_OrganizationalUnit_ADD_UserArea(struct zx_hrxml_OrganizationalUnit_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnit_DEL_UserArea) */

void zx_hrxml_OrganizationalUnit_DEL_UserArea(struct zx_hrxml_OrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_OrganizationalUnit_GET_hierarchicalRole) */
struct zx_str* zx_hrxml_OrganizationalUnit_GET_hierarchicalRole(struct zx_hrxml_OrganizationalUnit_s* x) { return x->hierarchicalRole; }
/* FUNC(zx_hrxml_OrganizationalUnit_PUT_hierarchicalRole) */
void zx_hrxml_OrganizationalUnit_PUT_hierarchicalRole(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_str* y) { x->hierarchicalRole = y; }
/* FUNC(zx_hrxml_OrganizationalUnit_GET_typeOfGroup) */
struct zx_str* zx_hrxml_OrganizationalUnit_GET_typeOfGroup(struct zx_hrxml_OrganizationalUnit_s* x) { return x->typeOfGroup; }
/* FUNC(zx_hrxml_OrganizationalUnit_PUT_typeOfGroup) */
void zx_hrxml_OrganizationalUnit_PUT_typeOfGroup(struct zx_hrxml_OrganizationalUnit_s* x, struct zx_str* y) { x->typeOfGroup = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OrganizationalUnitId_NUM_IdValue) */

int zx_hrxml_OrganizationalUnitId_NUM_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OrganizationalUnitId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_OrganizationalUnitId_GET_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnitId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_OrganizationalUnitId_POP_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OrganizationalUnitId_PUSH_IdValue) */

void zx_hrxml_OrganizationalUnitId_PUSH_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_OrganizationalUnitId_REV_IdValue) */

void zx_hrxml_OrganizationalUnitId_REV_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnitId_PUT_IdValue) */

void zx_hrxml_OrganizationalUnitId_PUT_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OrganizationalUnitId_ADD_IdValue) */

void zx_hrxml_OrganizationalUnitId_ADD_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OrganizationalUnitId_DEL_IdValue) */

void zx_hrxml_OrganizationalUnitId_DEL_IdValue(struct zx_hrxml_OrganizationalUnitId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_OrganizationalUnitId_GET_idOwner) */
struct zx_str* zx_hrxml_OrganizationalUnitId_GET_idOwner(struct zx_hrxml_OrganizationalUnitId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_OrganizationalUnitId_PUT_idOwner) */
void zx_hrxml_OrganizationalUnitId_PUT_idOwner(struct zx_hrxml_OrganizationalUnitId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_OrganizationalUnitId_GET_validFrom) */
struct zx_str* zx_hrxml_OrganizationalUnitId_GET_validFrom(struct zx_hrxml_OrganizationalUnitId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_OrganizationalUnitId_PUT_validFrom) */
void zx_hrxml_OrganizationalUnitId_PUT_validFrom(struct zx_hrxml_OrganizationalUnitId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_OrganizationalUnitId_GET_validTo) */
struct zx_str* zx_hrxml_OrganizationalUnitId_GET_validTo(struct zx_hrxml_OrganizationalUnitId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_OrganizationalUnitId_PUT_validTo) */
void zx_hrxml_OrganizationalUnitId_PUT_validTo(struct zx_hrxml_OrganizationalUnitId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OriginalDate_NUM_AnyDate) */

int zx_hrxml_OriginalDate_NUM_AnyDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OriginalDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_OriginalDate_GET_AnyDate(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_OriginalDate_POP_AnyDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_PUSH_AnyDate) */

void zx_hrxml_OriginalDate_PUSH_AnyDate(struct zx_hrxml_OriginalDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_OriginalDate_REV_AnyDate) */

void zx_hrxml_OriginalDate_REV_AnyDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OriginalDate_PUT_AnyDate) */

void zx_hrxml_OriginalDate_PUT_AnyDate(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OriginalDate_ADD_AnyDate) */

void zx_hrxml_OriginalDate_ADD_AnyDate(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OriginalDate_DEL_AnyDate) */

void zx_hrxml_OriginalDate_DEL_AnyDate(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OriginalDate_NUM_YearMonth) */

int zx_hrxml_OriginalDate_NUM_YearMonth(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OriginalDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_OriginalDate_GET_YearMonth(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_OriginalDate_POP_YearMonth(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_PUSH_YearMonth) */

void zx_hrxml_OriginalDate_PUSH_YearMonth(struct zx_hrxml_OriginalDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_OriginalDate_REV_YearMonth) */

void zx_hrxml_OriginalDate_REV_YearMonth(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OriginalDate_PUT_YearMonth) */

void zx_hrxml_OriginalDate_PUT_YearMonth(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OriginalDate_ADD_YearMonth) */

void zx_hrxml_OriginalDate_ADD_YearMonth(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OriginalDate_DEL_YearMonth) */

void zx_hrxml_OriginalDate_DEL_YearMonth(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OriginalDate_NUM_Year) */

int zx_hrxml_OriginalDate_NUM_Year(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OriginalDate_GET_Year) */

struct zx_elem_s* zx_hrxml_OriginalDate_GET_Year(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_POP_Year) */

struct zx_elem_s* zx_hrxml_OriginalDate_POP_Year(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_PUSH_Year) */

void zx_hrxml_OriginalDate_PUSH_Year(struct zx_hrxml_OriginalDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_OriginalDate_REV_Year) */

void zx_hrxml_OriginalDate_REV_Year(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OriginalDate_PUT_Year) */

void zx_hrxml_OriginalDate_PUT_Year(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OriginalDate_ADD_Year) */

void zx_hrxml_OriginalDate_ADD_Year(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OriginalDate_DEL_Year) */

void zx_hrxml_OriginalDate_DEL_Year(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OriginalDate_NUM_MonthDay) */

int zx_hrxml_OriginalDate_NUM_MonthDay(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OriginalDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_OriginalDate_GET_MonthDay(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_OriginalDate_POP_MonthDay(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_PUSH_MonthDay) */

void zx_hrxml_OriginalDate_PUSH_MonthDay(struct zx_hrxml_OriginalDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_OriginalDate_REV_MonthDay) */

void zx_hrxml_OriginalDate_REV_MonthDay(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OriginalDate_PUT_MonthDay) */

void zx_hrxml_OriginalDate_PUT_MonthDay(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OriginalDate_ADD_MonthDay) */

void zx_hrxml_OriginalDate_ADD_MonthDay(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OriginalDate_DEL_MonthDay) */

void zx_hrxml_OriginalDate_DEL_MonthDay(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OriginalDate_NUM_StringDate) */

int zx_hrxml_OriginalDate_NUM_StringDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OriginalDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_OriginalDate_GET_StringDate(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_OriginalDate_POP_StringDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OriginalDate_PUSH_StringDate) */

void zx_hrxml_OriginalDate_PUSH_StringDate(struct zx_hrxml_OriginalDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_OriginalDate_REV_StringDate) */

void zx_hrxml_OriginalDate_REV_StringDate(struct zx_hrxml_OriginalDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OriginalDate_PUT_StringDate) */

void zx_hrxml_OriginalDate_PUT_StringDate(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OriginalDate_ADD_StringDate) */

void zx_hrxml_OriginalDate_ADD_StringDate(struct zx_hrxml_OriginalDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OriginalDate_DEL_StringDate) */

void zx_hrxml_OriginalDate_DEL_StringDate(struct zx_hrxml_OriginalDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_OriginalDate_GET_dateDescription) */
struct zx_str* zx_hrxml_OriginalDate_GET_dateDescription(struct zx_hrxml_OriginalDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_OriginalDate_PUT_dateDescription) */
void zx_hrxml_OriginalDate_PUT_dateDescription(struct zx_hrxml_OriginalDate_s* x, struct zx_str* y) { x->dateDescription = y; }





/* FUNC(zx_hrxml_OtherBenefits_GET_type) */
struct zx_str* zx_hrxml_OtherBenefits_GET_type(struct zx_hrxml_OtherBenefits_s* x) { return x->type; }
/* FUNC(zx_hrxml_OtherBenefits_PUT_type) */
void zx_hrxml_OtherBenefits_PUT_type(struct zx_hrxml_OtherBenefits_s* x, struct zx_str* y) { x->type = y; }





/* FUNC(zx_hrxml_OtherCompensation_GET_type) */
struct zx_str* zx_hrxml_OtherCompensation_GET_type(struct zx_hrxml_OtherCompensation_s* x) { return x->type; }
/* FUNC(zx_hrxml_OtherCompensation_PUT_type) */
void zx_hrxml_OtherCompensation_PUT_type(struct zx_hrxml_OtherCompensation_s* x, struct zx_str* y) { x->type = y; }
/* FUNC(zx_hrxml_OtherCompensation_GET_validFrom) */
struct zx_str* zx_hrxml_OtherCompensation_GET_validFrom(struct zx_hrxml_OtherCompensation_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_OtherCompensation_PUT_validFrom) */
void zx_hrxml_OtherCompensation_PUT_validFrom(struct zx_hrxml_OtherCompensation_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_OtherCompensation_GET_validTo) */
struct zx_str* zx_hrxml_OtherCompensation_GET_validTo(struct zx_hrxml_OtherCompensation_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_OtherCompensation_PUT_validTo) */
void zx_hrxml_OtherCompensation_PUT_validTo(struct zx_hrxml_OtherCompensation_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherDescriptors_NUM_Name) */

int zx_hrxml_OtherDescriptors_NUM_Name(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherDescriptors_GET_Name) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_GET_Name(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_POP_Name) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_POP_Name(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_PUSH_Name) */

void zx_hrxml_OtherDescriptors_PUSH_Name(struct zx_hrxml_OtherDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_OtherDescriptors_REV_Name) */

void zx_hrxml_OtherDescriptors_REV_Name(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_PUT_Name) */

void zx_hrxml_OtherDescriptors_PUT_Name(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_ADD_Name) */

void zx_hrxml_OtherDescriptors_ADD_Name(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherDescriptors_DEL_Name) */

void zx_hrxml_OtherDescriptors_DEL_Name(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherDescriptors_NUM_Applicable) */

int zx_hrxml_OtherDescriptors_NUM_Applicable(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Applicable; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherDescriptors_GET_Applicable) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_GET_Applicable(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Applicable; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_POP_Applicable) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_POP_Applicable(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Applicable;
  if (y)
    x->Applicable = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_PUSH_Applicable) */

void zx_hrxml_OtherDescriptors_PUSH_Applicable(struct zx_hrxml_OtherDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Applicable->g;
  x->Applicable = z;
}

/* FUNC(zx_hrxml_OtherDescriptors_REV_Applicable) */

void zx_hrxml_OtherDescriptors_REV_Applicable(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Applicable;
  if (!y) return;
  x->Applicable = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Applicable->g;
    x->Applicable = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_PUT_Applicable) */

void zx_hrxml_OtherDescriptors_PUT_Applicable(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Applicable;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Applicable = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_ADD_Applicable) */

void zx_hrxml_OtherDescriptors_ADD_Applicable(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Applicable->g;
    x->Applicable = z;
    return;
  case -1:
    y = x->Applicable;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Applicable; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherDescriptors_DEL_Applicable) */

void zx_hrxml_OtherDescriptors_DEL_Applicable(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Applicable = (struct zx_elem_s*)x->Applicable->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Applicable;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Applicable; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherDescriptors_NUM_Value) */

int zx_hrxml_OtherDescriptors_NUM_Value(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Value; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherDescriptors_GET_Value) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_GET_Value(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Value; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_POP_Value) */

struct zx_elem_s* zx_hrxml_OtherDescriptors_POP_Value(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Value;
  if (y)
    x->Value = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_PUSH_Value) */

void zx_hrxml_OtherDescriptors_PUSH_Value(struct zx_hrxml_OtherDescriptors_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Value->g;
  x->Value = z;
}

/* FUNC(zx_hrxml_OtherDescriptors_REV_Value) */

void zx_hrxml_OtherDescriptors_REV_Value(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Value;
  if (!y) return;
  x->Value = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Value->g;
    x->Value = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_PUT_Value) */

void zx_hrxml_OtherDescriptors_PUT_Value(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Value;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Value = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_ADD_Value) */

void zx_hrxml_OtherDescriptors_ADD_Value(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Value->g;
    x->Value = z;
    return;
  case -1:
    y = x->Value;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherDescriptors_DEL_Value) */

void zx_hrxml_OtherDescriptors_DEL_Value(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Value = (struct zx_elem_s*)x->Value->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Value;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherDescriptors_NUM_List) */

int zx_hrxml_OtherDescriptors_NUM_List(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_hrxml_List_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->List; y; ++n, y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherDescriptors_GET_List) */

struct zx_hrxml_List_s* zx_hrxml_OtherDescriptors_GET_List(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_hrxml_List_s* y;
  if (!x) return 0;
  for (y = x->List; n>=0 && y; --n, y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_POP_List) */

struct zx_hrxml_List_s* zx_hrxml_OtherDescriptors_POP_List(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_hrxml_List_s* y;
  if (!x) return 0;
  y = x->List;
  if (y)
    x->List = (struct zx_hrxml_List_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherDescriptors_PUSH_List) */

void zx_hrxml_OtherDescriptors_PUSH_List(struct zx_hrxml_OtherDescriptors_s* x, struct zx_hrxml_List_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->List->gg.g;
  x->List = z;
}

/* FUNC(zx_hrxml_OtherDescriptors_REV_List) */

void zx_hrxml_OtherDescriptors_REV_List(struct zx_hrxml_OtherDescriptors_s* x)
{
  struct zx_hrxml_List_s* nxt;
  struct zx_hrxml_List_s* y;
  if (!x) return;
  y = x->List;
  if (!y) return;
  x->List = 0;
  while (y) {
    nxt = (struct zx_hrxml_List_s*)y->gg.g.n;
    y->gg.g.n = &x->List->gg.g;
    x->List = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_PUT_List) */

void zx_hrxml_OtherDescriptors_PUT_List(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_hrxml_List_s* z)
{
  struct zx_hrxml_List_s* y;
  if (!x || !z) return;
  y = x->List;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->List = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OtherDescriptors_ADD_List) */

void zx_hrxml_OtherDescriptors_ADD_List(struct zx_hrxml_OtherDescriptors_s* x, int n, struct zx_hrxml_List_s* z)
{
  struct zx_hrxml_List_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->List->gg.g;
    x->List = z;
    return;
  case -1:
    y = x->List;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->List; n > 1 && y; --n, y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OtherDescriptors_DEL_List) */

void zx_hrxml_OtherDescriptors_DEL_List(struct zx_hrxml_OtherDescriptors_s* x, int n)
{
  struct zx_hrxml_List_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->List = (struct zx_hrxml_List_s*)x->List->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_List_s*)x->List;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->List; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_List_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_OtherHonors_GET_type) */
struct zx_str* zx_hrxml_OtherHonors_GET_type(struct zx_hrxml_OtherHonors_s* x) { return x->type; }
/* FUNC(zx_hrxml_OtherHonors_PUT_type) */
void zx_hrxml_OtherHonors_PUT_type(struct zx_hrxml_OtherHonors_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPay_NUM_OtherPayAmountMin) */

int zx_hrxml_OtherPay_NUM_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPayAmountMin; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPay_GET_OtherPayAmountMin) */

struct zx_elem_s* zx_hrxml_OtherPay_GET_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OtherPayAmountMin; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_POP_OtherPayAmountMin) */

struct zx_elem_s* zx_hrxml_OtherPay_POP_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OtherPayAmountMin;
  if (y)
    x->OtherPayAmountMin = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_PUSH_OtherPayAmountMin) */

void zx_hrxml_OtherPay_PUSH_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OtherPayAmountMin->g;
  x->OtherPayAmountMin = z;
}

/* FUNC(zx_hrxml_OtherPay_REV_OtherPayAmountMin) */

void zx_hrxml_OtherPay_REV_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OtherPayAmountMin;
  if (!y) return;
  x->OtherPayAmountMin = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OtherPayAmountMin->g;
    x->OtherPayAmountMin = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPay_PUT_OtherPayAmountMin) */

void zx_hrxml_OtherPay_PUT_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OtherPayAmountMin;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OtherPayAmountMin = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPay_ADD_OtherPayAmountMin) */

void zx_hrxml_OtherPay_ADD_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OtherPayAmountMin->g;
    x->OtherPayAmountMin = z;
    return;
  case -1:
    y = x->OtherPayAmountMin;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayAmountMin; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPay_DEL_OtherPayAmountMin) */

void zx_hrxml_OtherPay_DEL_OtherPayAmountMin(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPayAmountMin = (struct zx_elem_s*)x->OtherPayAmountMin->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OtherPayAmountMin;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayAmountMin; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPay_NUM_OtherPayAmountMax) */

int zx_hrxml_OtherPay_NUM_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPayAmountMax; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPay_GET_OtherPayAmountMax) */

struct zx_elem_s* zx_hrxml_OtherPay_GET_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OtherPayAmountMax; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_POP_OtherPayAmountMax) */

struct zx_elem_s* zx_hrxml_OtherPay_POP_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OtherPayAmountMax;
  if (y)
    x->OtherPayAmountMax = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_PUSH_OtherPayAmountMax) */

void zx_hrxml_OtherPay_PUSH_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OtherPayAmountMax->g;
  x->OtherPayAmountMax = z;
}

/* FUNC(zx_hrxml_OtherPay_REV_OtherPayAmountMax) */

void zx_hrxml_OtherPay_REV_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OtherPayAmountMax;
  if (!y) return;
  x->OtherPayAmountMax = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OtherPayAmountMax->g;
    x->OtherPayAmountMax = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPay_PUT_OtherPayAmountMax) */

void zx_hrxml_OtherPay_PUT_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OtherPayAmountMax;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OtherPayAmountMax = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPay_ADD_OtherPayAmountMax) */

void zx_hrxml_OtherPay_ADD_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OtherPayAmountMax->g;
    x->OtherPayAmountMax = z;
    return;
  case -1:
    y = x->OtherPayAmountMax;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayAmountMax; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPay_DEL_OtherPayAmountMax) */

void zx_hrxml_OtherPay_DEL_OtherPayAmountMax(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPayAmountMax = (struct zx_elem_s*)x->OtherPayAmountMax->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OtherPayAmountMax;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayAmountMax; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPay_NUM_OtherPayCalculation) */

int zx_hrxml_OtherPay_NUM_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPayCalculation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPay_GET_OtherPayCalculation) */

struct zx_elem_s* zx_hrxml_OtherPay_GET_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OtherPayCalculation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_POP_OtherPayCalculation) */

struct zx_elem_s* zx_hrxml_OtherPay_POP_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OtherPayCalculation;
  if (y)
    x->OtherPayCalculation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_PUSH_OtherPayCalculation) */

void zx_hrxml_OtherPay_PUSH_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OtherPayCalculation->g;
  x->OtherPayCalculation = z;
}

/* FUNC(zx_hrxml_OtherPay_REV_OtherPayCalculation) */

void zx_hrxml_OtherPay_REV_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OtherPayCalculation;
  if (!y) return;
  x->OtherPayCalculation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OtherPayCalculation->g;
    x->OtherPayCalculation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPay_PUT_OtherPayCalculation) */

void zx_hrxml_OtherPay_PUT_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OtherPayCalculation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OtherPayCalculation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPay_ADD_OtherPayCalculation) */

void zx_hrxml_OtherPay_ADD_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OtherPayCalculation->g;
    x->OtherPayCalculation = z;
    return;
  case -1:
    y = x->OtherPayCalculation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayCalculation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPay_DEL_OtherPayCalculation) */

void zx_hrxml_OtherPay_DEL_OtherPayCalculation(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPayCalculation = (struct zx_elem_s*)x->OtherPayCalculation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OtherPayCalculation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OtherPayCalculation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPay_NUM_Comments) */

int zx_hrxml_OtherPay_NUM_Comments(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPay_GET_Comments) */

struct zx_elem_s* zx_hrxml_OtherPay_GET_Comments(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_POP_Comments) */

struct zx_elem_s* zx_hrxml_OtherPay_POP_Comments(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPay_PUSH_Comments) */

void zx_hrxml_OtherPay_PUSH_Comments(struct zx_hrxml_OtherPay_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_OtherPay_REV_Comments) */

void zx_hrxml_OtherPay_REV_Comments(struct zx_hrxml_OtherPay_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPay_PUT_Comments) */

void zx_hrxml_OtherPay_PUT_Comments(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPay_ADD_Comments) */

void zx_hrxml_OtherPay_ADD_Comments(struct zx_hrxml_OtherPay_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPay_DEL_Comments) */

void zx_hrxml_OtherPay_DEL_Comments(struct zx_hrxml_OtherPay_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_OtherPay_GET_currencyCode) */
struct zx_str* zx_hrxml_OtherPay_GET_currencyCode(struct zx_hrxml_OtherPay_s* x) { return x->currencyCode; }
/* FUNC(zx_hrxml_OtherPay_PUT_currencyCode) */
void zx_hrxml_OtherPay_PUT_currencyCode(struct zx_hrxml_OtherPay_s* x, struct zx_str* y) { x->currencyCode = y; }
/* FUNC(zx_hrxml_OtherPay_GET_otherInterval) */
struct zx_str* zx_hrxml_OtherPay_GET_otherInterval(struct zx_hrxml_OtherPay_s* x) { return x->otherInterval; }
/* FUNC(zx_hrxml_OtherPay_PUT_otherInterval) */
void zx_hrxml_OtherPay_PUT_otherInterval(struct zx_hrxml_OtherPay_s* x, struct zx_str* y) { x->otherInterval = y; }
/* FUNC(zx_hrxml_OtherPay_GET_otherPayType) */
struct zx_str* zx_hrxml_OtherPay_GET_otherPayType(struct zx_hrxml_OtherPay_s* x) { return x->otherPayType; }
/* FUNC(zx_hrxml_OtherPay_PUT_otherPayType) */
void zx_hrxml_OtherPay_PUT_otherPayType(struct zx_hrxml_OtherPay_s* x, struct zx_str* y) { x->otherPayType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Title) */

int zx_hrxml_OtherPublication_NUM_Title(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Title) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_Title(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Title) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_Title(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Title) */

void zx_hrxml_OtherPublication_PUSH_Title(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Title) */

void zx_hrxml_OtherPublication_REV_Title(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Title) */

void zx_hrxml_OtherPublication_PUT_Title(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Title) */

void zx_hrxml_OtherPublication_ADD_Title(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Title) */

void zx_hrxml_OtherPublication_DEL_Title(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Name) */

int zx_hrxml_OtherPublication_NUM_Name(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Name) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_Name(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Name) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_Name(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Name) */

void zx_hrxml_OtherPublication_PUSH_Name(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Name) */

void zx_hrxml_OtherPublication_REV_Name(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Name) */

void zx_hrxml_OtherPublication_PUT_Name(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Name) */

void zx_hrxml_OtherPublication_ADD_Name(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Name) */

void zx_hrxml_OtherPublication_DEL_Name(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_PublicationDate) */

int zx_hrxml_OtherPublication_NUM_PublicationDate(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationDate; y; ++n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_OtherPublication_GET_PublicationDate(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  for (y = x->PublicationDate; n>=0 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_PublicationDate) */

struct zx_hrxml_PublicationDate_s* zx_hrxml_OtherPublication_POP_PublicationDate(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return 0;
  y = x->PublicationDate;
  if (y)
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_PublicationDate) */

void zx_hrxml_OtherPublication_PUSH_PublicationDate(struct zx_hrxml_OtherPublication_s* x, struct zx_hrxml_PublicationDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationDate->gg.g;
  x->PublicationDate = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_PublicationDate) */

void zx_hrxml_OtherPublication_REV_PublicationDate(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_PublicationDate_s* nxt;
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  y = x->PublicationDate;
  if (!y) return;
  x->PublicationDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_PublicationDate) */

void zx_hrxml_OtherPublication_PUT_PublicationDate(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  y = x->PublicationDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_PublicationDate) */

void zx_hrxml_OtherPublication_ADD_PublicationDate(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_hrxml_PublicationDate_s* z)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationDate->gg.g;
    x->PublicationDate = z;
    return;
  case -1:
    y = x->PublicationDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_PublicationDate) */

void zx_hrxml_OtherPublication_DEL_PublicationDate(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_hrxml_PublicationDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationDate = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationDate_s*)x->PublicationDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Link) */

int zx_hrxml_OtherPublication_NUM_Link(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Link) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_Link(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Link) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_Link(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Link) */

void zx_hrxml_OtherPublication_PUSH_Link(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Link) */

void zx_hrxml_OtherPublication_REV_Link(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Link) */

void zx_hrxml_OtherPublication_PUT_Link(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Link) */

void zx_hrxml_OtherPublication_ADD_Link(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Link) */

void zx_hrxml_OtherPublication_DEL_Link(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Abstract) */

int zx_hrxml_OtherPublication_NUM_Abstract(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Abstract; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Abstract) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_Abstract(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Abstract; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Abstract) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_Abstract(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Abstract;
  if (y)
    x->Abstract = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Abstract) */

void zx_hrxml_OtherPublication_PUSH_Abstract(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Abstract->g;
  x->Abstract = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Abstract) */

void zx_hrxml_OtherPublication_REV_Abstract(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Abstract;
  if (!y) return;
  x->Abstract = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Abstract->g;
    x->Abstract = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Abstract) */

void zx_hrxml_OtherPublication_PUT_Abstract(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Abstract;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Abstract = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Abstract) */

void zx_hrxml_OtherPublication_ADD_Abstract(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Abstract->g;
    x->Abstract = z;
    return;
  case -1:
    y = x->Abstract;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Abstract) */

void zx_hrxml_OtherPublication_DEL_Abstract(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Abstract = (struct zx_elem_s*)x->Abstract->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Abstract;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Abstract; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Copyright) */

int zx_hrxml_OtherPublication_NUM_Copyright(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Copyright; y; ++n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_OtherPublication_GET_Copyright(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  for (y = x->Copyright; n>=0 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Copyright) */

struct zx_hrxml_Copyright_s* zx_hrxml_OtherPublication_POP_Copyright(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return 0;
  y = x->Copyright;
  if (y)
    x->Copyright = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Copyright) */

void zx_hrxml_OtherPublication_PUSH_Copyright(struct zx_hrxml_OtherPublication_s* x, struct zx_hrxml_Copyright_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Copyright->gg.g;
  x->Copyright = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Copyright) */

void zx_hrxml_OtherPublication_REV_Copyright(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_hrxml_Copyright_s* nxt;
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  y = x->Copyright;
  if (!y) return;
  x->Copyright = 0;
  while (y) {
    nxt = (struct zx_hrxml_Copyright_s*)y->gg.g.n;
    y->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Copyright) */

void zx_hrxml_OtherPublication_PUT_Copyright(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  y = x->Copyright;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Copyright = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Copyright) */

void zx_hrxml_OtherPublication_ADD_Copyright(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_hrxml_Copyright_s* z)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Copyright->gg.g;
    x->Copyright = z;
    return;
  case -1:
    y = x->Copyright;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Copyright) */

void zx_hrxml_OtherPublication_DEL_Copyright(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_hrxml_Copyright_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Copyright = (struct zx_hrxml_Copyright_s*)x->Copyright->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Copyright_s*)x->Copyright;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Copyright; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Copyright_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_Comments) */

int zx_hrxml_OtherPublication_NUM_Comments(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_Comments) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_Comments(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_Comments) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_Comments(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_Comments) */

void zx_hrxml_OtherPublication_PUSH_Comments(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_Comments) */

void zx_hrxml_OtherPublication_REV_Comments(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_Comments) */

void zx_hrxml_OtherPublication_PUT_Comments(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_Comments) */

void zx_hrxml_OtherPublication_ADD_Comments(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_Comments) */

void zx_hrxml_OtherPublication_DEL_Comments(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_ISSN) */

int zx_hrxml_OtherPublication_NUM_ISSN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISSN; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_ISSN) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_ISSN(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISSN; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_ISSN) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_ISSN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISSN;
  if (y)
    x->ISSN = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_ISSN) */

void zx_hrxml_OtherPublication_PUSH_ISSN(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISSN->g;
  x->ISSN = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_ISSN) */

void zx_hrxml_OtherPublication_REV_ISSN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISSN;
  if (!y) return;
  x->ISSN = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISSN->g;
    x->ISSN = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_ISSN) */

void zx_hrxml_OtherPublication_PUT_ISSN(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISSN;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISSN = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_ISSN) */

void zx_hrxml_OtherPublication_ADD_ISSN(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISSN->g;
    x->ISSN = z;
    return;
  case -1:
    y = x->ISSN;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_ISSN) */

void zx_hrxml_OtherPublication_DEL_ISSN(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISSN = (struct zx_elem_s*)x->ISSN->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISSN;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISSN; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_ISBN) */

int zx_hrxml_OtherPublication_NUM_ISBN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISBN; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_ISBN) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_ISBN(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISBN; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_ISBN) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_ISBN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISBN;
  if (y)
    x->ISBN = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_ISBN) */

void zx_hrxml_OtherPublication_PUSH_ISBN(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISBN->g;
  x->ISBN = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_ISBN) */

void zx_hrxml_OtherPublication_REV_ISBN(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISBN;
  if (!y) return;
  x->ISBN = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISBN->g;
    x->ISBN = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_ISBN) */

void zx_hrxml_OtherPublication_PUT_ISBN(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISBN;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISBN = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_ISBN) */

void zx_hrxml_OtherPublication_ADD_ISBN(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISBN->g;
    x->ISBN = z;
    return;
  case -1:
    y = x->ISBN;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISBN; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_ISBN) */

void zx_hrxml_OtherPublication_DEL_ISBN(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISBN = (struct zx_elem_s*)x->ISBN->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISBN;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISBN; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_NumberOfPages) */

int zx_hrxml_OtherPublication_NUM_NumberOfPages(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NumberOfPages; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_NumberOfPages) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_NumberOfPages(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->NumberOfPages; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_NumberOfPages) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_NumberOfPages(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->NumberOfPages;
  if (y)
    x->NumberOfPages = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_NumberOfPages) */

void zx_hrxml_OtherPublication_PUSH_NumberOfPages(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->NumberOfPages->g;
  x->NumberOfPages = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_NumberOfPages) */

void zx_hrxml_OtherPublication_REV_NumberOfPages(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->NumberOfPages;
  if (!y) return;
  x->NumberOfPages = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->NumberOfPages->g;
    x->NumberOfPages = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_NumberOfPages) */

void zx_hrxml_OtherPublication_PUT_NumberOfPages(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->NumberOfPages;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->NumberOfPages = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_NumberOfPages) */

void zx_hrxml_OtherPublication_ADD_NumberOfPages(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->NumberOfPages->g;
    x->NumberOfPages = z;
    return;
  case -1:
    y = x->NumberOfPages;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfPages; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_NumberOfPages) */

void zx_hrxml_OtherPublication_DEL_NumberOfPages(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NumberOfPages = (struct zx_elem_s*)x->NumberOfPages->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->NumberOfPages;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NumberOfPages; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_PublisherName) */

int zx_hrxml_OtherPublication_NUM_PublisherName(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublisherName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_PublisherName) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_PublisherName(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PublisherName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_PublisherName) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_PublisherName(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PublisherName;
  if (y)
    x->PublisherName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_PublisherName) */

void zx_hrxml_OtherPublication_PUSH_PublisherName(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PublisherName->g;
  x->PublisherName = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_PublisherName) */

void zx_hrxml_OtherPublication_REV_PublisherName(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PublisherName;
  if (!y) return;
  x->PublisherName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PublisherName->g;
    x->PublisherName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_PublisherName) */

void zx_hrxml_OtherPublication_PUT_PublisherName(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PublisherName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PublisherName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_PublisherName) */

void zx_hrxml_OtherPublication_ADD_PublisherName(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PublisherName->g;
    x->PublisherName = z;
    return;
  case -1:
    y = x->PublisherName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_PublisherName) */

void zx_hrxml_OtherPublication_DEL_PublisherName(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublisherName = (struct zx_elem_s*)x->PublisherName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PublisherName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_OtherPublication_NUM_PublisherLocation) */

int zx_hrxml_OtherPublication_NUM_PublisherLocation(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublisherLocation; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_OtherPublication_GET_PublisherLocation) */

struct zx_elem_s* zx_hrxml_OtherPublication_GET_PublisherLocation(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PublisherLocation; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_POP_PublisherLocation) */

struct zx_elem_s* zx_hrxml_OtherPublication_POP_PublisherLocation(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PublisherLocation;
  if (y)
    x->PublisherLocation = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_OtherPublication_PUSH_PublisherLocation) */

void zx_hrxml_OtherPublication_PUSH_PublisherLocation(struct zx_hrxml_OtherPublication_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PublisherLocation->g;
  x->PublisherLocation = z;
}

/* FUNC(zx_hrxml_OtherPublication_REV_PublisherLocation) */

void zx_hrxml_OtherPublication_REV_PublisherLocation(struct zx_hrxml_OtherPublication_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PublisherLocation;
  if (!y) return;
  x->PublisherLocation = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PublisherLocation->g;
    x->PublisherLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_OtherPublication_PUT_PublisherLocation) */

void zx_hrxml_OtherPublication_PUT_PublisherLocation(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PublisherLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PublisherLocation = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_OtherPublication_ADD_PublisherLocation) */

void zx_hrxml_OtherPublication_ADD_PublisherLocation(struct zx_hrxml_OtherPublication_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PublisherLocation->g;
    x->PublisherLocation = z;
    return;
  case -1:
    y = x->PublisherLocation;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherLocation; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_OtherPublication_DEL_PublisherLocation) */

void zx_hrxml_OtherPublication_DEL_PublisherLocation(struct zx_hrxml_OtherPublication_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublisherLocation = (struct zx_elem_s*)x->PublisherLocation->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PublisherLocation;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PublisherLocation; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_OtherPublication_GET_type) */
struct zx_str* zx_hrxml_OtherPublication_GET_type(struct zx_hrxml_OtherPublication_s* x) { return x->type; }
/* FUNC(zx_hrxml_OtherPublication_PUT_type) */
void zx_hrxml_OtherPublication_PUT_type(struct zx_hrxml_OtherPublication_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Pager_NUM_FormattedNumber) */

int zx_hrxml_Pager_NUM_FormattedNumber(struct zx_hrxml_Pager_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Pager_GET_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Pager_GET_FormattedNumber(struct zx_hrxml_Pager_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Pager_POP_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Pager_POP_FormattedNumber(struct zx_hrxml_Pager_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedNumber;
  if (y)
    x->FormattedNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Pager_PUSH_FormattedNumber) */

void zx_hrxml_Pager_PUSH_FormattedNumber(struct zx_hrxml_Pager_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedNumber->g;
  x->FormattedNumber = z;
}

/* FUNC(zx_hrxml_Pager_REV_FormattedNumber) */

void zx_hrxml_Pager_REV_FormattedNumber(struct zx_hrxml_Pager_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedNumber;
  if (!y) return;
  x->FormattedNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Pager_PUT_FormattedNumber) */

void zx_hrxml_Pager_PUT_FormattedNumber(struct zx_hrxml_Pager_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Pager_ADD_FormattedNumber) */

void zx_hrxml_Pager_ADD_FormattedNumber(struct zx_hrxml_Pager_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = z;
    return;
  case -1:
    y = x->FormattedNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Pager_DEL_FormattedNumber) */

void zx_hrxml_Pager_DEL_FormattedNumber(struct zx_hrxml_Pager_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedNumber = (struct zx_elem_s*)x->FormattedNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_ParkingInstructions_GET_lang) */
struct zx_str* zx_hrxml_ParkingInstructions_GET_lang(struct zx_hrxml_ParkingInstructions_s* x) { return x->lang; }
/* FUNC(zx_hrxml_ParkingInstructions_PUT_lang) */
void zx_hrxml_ParkingInstructions_PUT_lang(struct zx_hrxml_ParkingInstructions_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Patent_NUM_PatentTitle) */

int zx_hrxml_Patent_NUM_PatentTitle(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PatentTitle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Patent_GET_PatentTitle) */

struct zx_elem_s* zx_hrxml_Patent_GET_PatentTitle(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PatentTitle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Patent_POP_PatentTitle) */

struct zx_elem_s* zx_hrxml_Patent_POP_PatentTitle(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PatentTitle;
  if (y)
    x->PatentTitle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Patent_PUSH_PatentTitle) */

void zx_hrxml_Patent_PUSH_PatentTitle(struct zx_hrxml_Patent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PatentTitle->g;
  x->PatentTitle = z;
}

/* FUNC(zx_hrxml_Patent_REV_PatentTitle) */

void zx_hrxml_Patent_REV_PatentTitle(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PatentTitle;
  if (!y) return;
  x->PatentTitle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PatentTitle->g;
    x->PatentTitle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Patent_PUT_PatentTitle) */

void zx_hrxml_Patent_PUT_PatentTitle(struct zx_hrxml_Patent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PatentTitle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PatentTitle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Patent_ADD_PatentTitle) */

void zx_hrxml_Patent_ADD_PatentTitle(struct zx_hrxml_Patent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PatentTitle->g;
    x->PatentTitle = z;
    return;
  case -1:
    y = x->PatentTitle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PatentTitle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Patent_DEL_PatentTitle) */

void zx_hrxml_Patent_DEL_PatentTitle(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PatentTitle = (struct zx_elem_s*)x->PatentTitle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PatentTitle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PatentTitle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Patent_NUM_Description) */

int zx_hrxml_Patent_NUM_Description(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Patent_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_Patent_GET_Description(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Patent_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_Patent_POP_Description(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Patent_PUSH_Description) */

void zx_hrxml_Patent_PUSH_Description(struct zx_hrxml_Patent_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_Patent_REV_Description) */

void zx_hrxml_Patent_REV_Description(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Patent_PUT_Description) */

void zx_hrxml_Patent_PUT_Description(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Patent_ADD_Description) */

void zx_hrxml_Patent_ADD_Description(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Patent_DEL_Description) */

void zx_hrxml_Patent_DEL_Description(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Patent_NUM_Inventors) */

int zx_hrxml_Patent_NUM_Inventors(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Inventors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Inventors; y; ++n, y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Patent_GET_Inventors) */

struct zx_hrxml_Inventors_s* zx_hrxml_Patent_GET_Inventors(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_Inventors_s* y;
  if (!x) return 0;
  for (y = x->Inventors; n>=0 && y; --n, y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Patent_POP_Inventors) */

struct zx_hrxml_Inventors_s* zx_hrxml_Patent_POP_Inventors(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Inventors_s* y;
  if (!x) return 0;
  y = x->Inventors;
  if (y)
    x->Inventors = (struct zx_hrxml_Inventors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Patent_PUSH_Inventors) */

void zx_hrxml_Patent_PUSH_Inventors(struct zx_hrxml_Patent_s* x, struct zx_hrxml_Inventors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Inventors->gg.g;
  x->Inventors = z;
}

/* FUNC(zx_hrxml_Patent_REV_Inventors) */

void zx_hrxml_Patent_REV_Inventors(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_Inventors_s* nxt;
  struct zx_hrxml_Inventors_s* y;
  if (!x) return;
  y = x->Inventors;
  if (!y) return;
  x->Inventors = 0;
  while (y) {
    nxt = (struct zx_hrxml_Inventors_s*)y->gg.g.n;
    y->gg.g.n = &x->Inventors->gg.g;
    x->Inventors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Patent_PUT_Inventors) */

void zx_hrxml_Patent_PUT_Inventors(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_Inventors_s* z)
{
  struct zx_hrxml_Inventors_s* y;
  if (!x || !z) return;
  y = x->Inventors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Inventors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Patent_ADD_Inventors) */

void zx_hrxml_Patent_ADD_Inventors(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_Inventors_s* z)
{
  struct zx_hrxml_Inventors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Inventors->gg.g;
    x->Inventors = z;
    return;
  case -1:
    y = x->Inventors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Inventors; n > 1 && y; --n, y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Patent_DEL_Inventors) */

void zx_hrxml_Patent_DEL_Inventors(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_Inventors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Inventors = (struct zx_hrxml_Inventors_s*)x->Inventors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Inventors_s*)x->Inventors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Inventors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Inventors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Patent_NUM_PatentDetail) */

int zx_hrxml_Patent_NUM_PatentDetail(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_PatentDetail_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PatentDetail; y; ++n, y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Patent_GET_PatentDetail) */

struct zx_hrxml_PatentDetail_s* zx_hrxml_Patent_GET_PatentDetail(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_PatentDetail_s* y;
  if (!x) return 0;
  for (y = x->PatentDetail; n>=0 && y; --n, y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Patent_POP_PatentDetail) */

struct zx_hrxml_PatentDetail_s* zx_hrxml_Patent_POP_PatentDetail(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_PatentDetail_s* y;
  if (!x) return 0;
  y = x->PatentDetail;
  if (y)
    x->PatentDetail = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Patent_PUSH_PatentDetail) */

void zx_hrxml_Patent_PUSH_PatentDetail(struct zx_hrxml_Patent_s* x, struct zx_hrxml_PatentDetail_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PatentDetail->gg.g;
  x->PatentDetail = z;
}

/* FUNC(zx_hrxml_Patent_REV_PatentDetail) */

void zx_hrxml_Patent_REV_PatentDetail(struct zx_hrxml_Patent_s* x)
{
  struct zx_hrxml_PatentDetail_s* nxt;
  struct zx_hrxml_PatentDetail_s* y;
  if (!x) return;
  y = x->PatentDetail;
  if (!y) return;
  x->PatentDetail = 0;
  while (y) {
    nxt = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n;
    y->gg.g.n = &x->PatentDetail->gg.g;
    x->PatentDetail = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Patent_PUT_PatentDetail) */

void zx_hrxml_Patent_PUT_PatentDetail(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_PatentDetail_s* z)
{
  struct zx_hrxml_PatentDetail_s* y;
  if (!x || !z) return;
  y = x->PatentDetail;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PatentDetail = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Patent_ADD_PatentDetail) */

void zx_hrxml_Patent_ADD_PatentDetail(struct zx_hrxml_Patent_s* x, int n, struct zx_hrxml_PatentDetail_s* z)
{
  struct zx_hrxml_PatentDetail_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PatentDetail->gg.g;
    x->PatentDetail = z;
    return;
  case -1:
    y = x->PatentDetail;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentDetail; n > 1 && y; --n, y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Patent_DEL_PatentDetail) */

void zx_hrxml_Patent_DEL_PatentDetail(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_hrxml_PatentDetail_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PatentDetail = (struct zx_hrxml_PatentDetail_s*)x->PatentDetail->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PatentDetail_s*)x->PatentDetail;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentDetail; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentDetail_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Patent_NUM_Link) */

int zx_hrxml_Patent_NUM_Link(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Patent_GET_Link) */

struct zx_elem_s* zx_hrxml_Patent_GET_Link(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Patent_POP_Link) */

struct zx_elem_s* zx_hrxml_Patent_POP_Link(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Patent_PUSH_Link) */

void zx_hrxml_Patent_PUSH_Link(struct zx_hrxml_Patent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_Patent_REV_Link) */

void zx_hrxml_Patent_REV_Link(struct zx_hrxml_Patent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Patent_PUT_Link) */

void zx_hrxml_Patent_PUT_Link(struct zx_hrxml_Patent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Patent_ADD_Link) */

void zx_hrxml_Patent_ADD_Link(struct zx_hrxml_Patent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Patent_DEL_Link) */

void zx_hrxml_Patent_DEL_Link(struct zx_hrxml_Patent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentDetail_NUM_IssuingAuthority) */

int zx_hrxml_PatentDetail_NUM_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IssuingAuthority; y; ++n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentDetail_GET_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_PatentDetail_GET_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  for (y = x->IssuingAuthority; n>=0 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentDetail_POP_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_PatentDetail_POP_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  y = x->IssuingAuthority;
  if (y)
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentDetail_PUSH_IssuingAuthority) */

void zx_hrxml_PatentDetail_PUSH_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x, struct zx_hrxml_IssuingAuthority_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IssuingAuthority->gg.g;
  x->IssuingAuthority = z;
}

/* FUNC(zx_hrxml_PatentDetail_REV_IssuingAuthority) */

void zx_hrxml_PatentDetail_REV_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* nxt;
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  y = x->IssuingAuthority;
  if (!y) return;
  x->IssuingAuthority = 0;
  while (y) {
    nxt = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
    y->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentDetail_PUT_IssuingAuthority) */

void zx_hrxml_PatentDetail_PUT_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  y = x->IssuingAuthority;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IssuingAuthority = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PatentDetail_ADD_IssuingAuthority) */

void zx_hrxml_PatentDetail_ADD_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = z;
    return;
  case -1:
    y = x->IssuingAuthority;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PatentDetail_DEL_IssuingAuthority) */

void zx_hrxml_PatentDetail_DEL_IssuingAuthority(struct zx_hrxml_PatentDetail_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentDetail_NUM_PatentMilestone) */

int zx_hrxml_PatentDetail_NUM_PatentMilestone(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_PatentMilestone_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PatentMilestone; y; ++n, y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentDetail_GET_PatentMilestone) */

struct zx_hrxml_PatentMilestone_s* zx_hrxml_PatentDetail_GET_PatentMilestone(struct zx_hrxml_PatentDetail_s* x, int n)
{
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x) return 0;
  for (y = x->PatentMilestone; n>=0 && y; --n, y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentDetail_POP_PatentMilestone) */

struct zx_hrxml_PatentMilestone_s* zx_hrxml_PatentDetail_POP_PatentMilestone(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x) return 0;
  y = x->PatentMilestone;
  if (y)
    x->PatentMilestone = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentDetail_PUSH_PatentMilestone) */

void zx_hrxml_PatentDetail_PUSH_PatentMilestone(struct zx_hrxml_PatentDetail_s* x, struct zx_hrxml_PatentMilestone_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PatentMilestone->gg.g;
  x->PatentMilestone = z;
}

/* FUNC(zx_hrxml_PatentDetail_REV_PatentMilestone) */

void zx_hrxml_PatentDetail_REV_PatentMilestone(struct zx_hrxml_PatentDetail_s* x)
{
  struct zx_hrxml_PatentMilestone_s* nxt;
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x) return;
  y = x->PatentMilestone;
  if (!y) return;
  x->PatentMilestone = 0;
  while (y) {
    nxt = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n;
    y->gg.g.n = &x->PatentMilestone->gg.g;
    x->PatentMilestone = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentDetail_PUT_PatentMilestone) */

void zx_hrxml_PatentDetail_PUT_PatentMilestone(struct zx_hrxml_PatentDetail_s* x, int n, struct zx_hrxml_PatentMilestone_s* z)
{
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x || !z) return;
  y = x->PatentMilestone;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PatentMilestone = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PatentDetail_ADD_PatentMilestone) */

void zx_hrxml_PatentDetail_ADD_PatentMilestone(struct zx_hrxml_PatentDetail_s* x, int n, struct zx_hrxml_PatentMilestone_s* z)
{
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PatentMilestone->gg.g;
    x->PatentMilestone = z;
    return;
  case -1:
    y = x->PatentMilestone;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentMilestone; n > 1 && y; --n, y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PatentDetail_DEL_PatentMilestone) */

void zx_hrxml_PatentDetail_DEL_PatentMilestone(struct zx_hrxml_PatentDetail_s* x, int n)
{
  struct zx_hrxml_PatentMilestone_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PatentMilestone = (struct zx_hrxml_PatentMilestone_s*)x->PatentMilestone->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PatentMilestone_s*)x->PatentMilestone;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentMilestone; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentMilestone_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentHistory_NUM_Patent) */

int zx_hrxml_PatentHistory_NUM_Patent(struct zx_hrxml_PatentHistory_s* x)
{
  struct zx_hrxml_Patent_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Patent; y; ++n, y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentHistory_GET_Patent) */

struct zx_hrxml_Patent_s* zx_hrxml_PatentHistory_GET_Patent(struct zx_hrxml_PatentHistory_s* x, int n)
{
  struct zx_hrxml_Patent_s* y;
  if (!x) return 0;
  for (y = x->Patent; n>=0 && y; --n, y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentHistory_POP_Patent) */

struct zx_hrxml_Patent_s* zx_hrxml_PatentHistory_POP_Patent(struct zx_hrxml_PatentHistory_s* x)
{
  struct zx_hrxml_Patent_s* y;
  if (!x) return 0;
  y = x->Patent;
  if (y)
    x->Patent = (struct zx_hrxml_Patent_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentHistory_PUSH_Patent) */

void zx_hrxml_PatentHistory_PUSH_Patent(struct zx_hrxml_PatentHistory_s* x, struct zx_hrxml_Patent_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Patent->gg.g;
  x->Patent = z;
}

/* FUNC(zx_hrxml_PatentHistory_REV_Patent) */

void zx_hrxml_PatentHistory_REV_Patent(struct zx_hrxml_PatentHistory_s* x)
{
  struct zx_hrxml_Patent_s* nxt;
  struct zx_hrxml_Patent_s* y;
  if (!x) return;
  y = x->Patent;
  if (!y) return;
  x->Patent = 0;
  while (y) {
    nxt = (struct zx_hrxml_Patent_s*)y->gg.g.n;
    y->gg.g.n = &x->Patent->gg.g;
    x->Patent = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentHistory_PUT_Patent) */

void zx_hrxml_PatentHistory_PUT_Patent(struct zx_hrxml_PatentHistory_s* x, int n, struct zx_hrxml_Patent_s* z)
{
  struct zx_hrxml_Patent_s* y;
  if (!x || !z) return;
  y = x->Patent;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Patent = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PatentHistory_ADD_Patent) */

void zx_hrxml_PatentHistory_ADD_Patent(struct zx_hrxml_PatentHistory_s* x, int n, struct zx_hrxml_Patent_s* z)
{
  struct zx_hrxml_Patent_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Patent->gg.g;
    x->Patent = z;
    return;
  case -1:
    y = x->Patent;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Patent; n > 1 && y; --n, y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PatentHistory_DEL_Patent) */

void zx_hrxml_PatentHistory_DEL_Patent(struct zx_hrxml_PatentHistory_s* x, int n)
{
  struct zx_hrxml_Patent_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Patent = (struct zx_hrxml_Patent_s*)x->Patent->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Patent_s*)x->Patent;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Patent; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Patent_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentMilestone_NUM_Id) */

int zx_hrxml_PatentMilestone_NUM_Id(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentMilestone_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PatentMilestone_GET_Id(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PatentMilestone_POP_Id(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_PUSH_Id) */

void zx_hrxml_PatentMilestone_PUSH_Id(struct zx_hrxml_PatentMilestone_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_PatentMilestone_REV_Id) */

void zx_hrxml_PatentMilestone_REV_Id(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_PUT_Id) */

void zx_hrxml_PatentMilestone_PUT_Id(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_ADD_Id) */

void zx_hrxml_PatentMilestone_ADD_Id(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PatentMilestone_DEL_Id) */

void zx_hrxml_PatentMilestone_DEL_Id(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentMilestone_NUM_Status) */

int zx_hrxml_PatentMilestone_NUM_Status(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Status_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Status; y; ++n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentMilestone_GET_Status) */

struct zx_hrxml_Status_s* zx_hrxml_PatentMilestone_GET_Status(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return 0;
  for (y = x->Status; n>=0 && y; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_POP_Status) */

struct zx_hrxml_Status_s* zx_hrxml_PatentMilestone_POP_Status(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return 0;
  y = x->Status;
  if (y)
    x->Status = (struct zx_hrxml_Status_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_PUSH_Status) */

void zx_hrxml_PatentMilestone_PUSH_Status(struct zx_hrxml_PatentMilestone_s* x, struct zx_hrxml_Status_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Status->gg.g;
  x->Status = z;
}

/* FUNC(zx_hrxml_PatentMilestone_REV_Status) */

void zx_hrxml_PatentMilestone_REV_Status(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_hrxml_Status_s* nxt;
  struct zx_hrxml_Status_s* y;
  if (!x) return;
  y = x->Status;
  if (!y) return;
  x->Status = 0;
  while (y) {
    nxt = (struct zx_hrxml_Status_s*)y->gg.g.n;
    y->gg.g.n = &x->Status->gg.g;
    x->Status = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_PUT_Status) */

void zx_hrxml_PatentMilestone_PUT_Status(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_hrxml_Status_s* z)
{
  struct zx_hrxml_Status_s* y;
  if (!x || !z) return;
  y = x->Status;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Status = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_ADD_Status) */

void zx_hrxml_PatentMilestone_ADD_Status(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_hrxml_Status_s* z)
{
  struct zx_hrxml_Status_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Status->gg.g;
    x->Status = z;
    return;
  case -1:
    y = x->Status;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Status; n > 1 && y; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PatentMilestone_DEL_Status) */

void zx_hrxml_PatentMilestone_DEL_Status(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_hrxml_Status_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Status = (struct zx_hrxml_Status_s*)x->Status->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Status_s*)x->Status;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Status; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Status_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PatentMilestone_NUM_Date) */

int zx_hrxml_PatentMilestone_NUM_Date(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Date; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PatentMilestone_GET_Date) */

struct zx_elem_s* zx_hrxml_PatentMilestone_GET_Date(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Date; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_POP_Date) */

struct zx_elem_s* zx_hrxml_PatentMilestone_POP_Date(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Date;
  if (y)
    x->Date = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PatentMilestone_PUSH_Date) */

void zx_hrxml_PatentMilestone_PUSH_Date(struct zx_hrxml_PatentMilestone_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Date->g;
  x->Date = z;
}

/* FUNC(zx_hrxml_PatentMilestone_REV_Date) */

void zx_hrxml_PatentMilestone_REV_Date(struct zx_hrxml_PatentMilestone_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Date;
  if (!y) return;
  x->Date = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Date->g;
    x->Date = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_PUT_Date) */

void zx_hrxml_PatentMilestone_PUT_Date(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Date;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Date = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PatentMilestone_ADD_Date) */

void zx_hrxml_PatentMilestone_ADD_Date(struct zx_hrxml_PatentMilestone_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Date->g;
    x->Date = z;
    return;
  case -1:
    y = x->Date;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Date; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PatentMilestone_DEL_Date) */

void zx_hrxml_PatentMilestone_DEL_Date(struct zx_hrxml_PatentMilestone_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Date = (struct zx_elem_s*)x->Date->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Date;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Date; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_LegalIdentifiers) */

int zx_hrxml_PersonDescriptors_NUM_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalIdentifiers; y; ++n, y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_LegalIdentifiers) */

struct zx_hrxml_LegalIdentifiers_s* zx_hrxml_PersonDescriptors_GET_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x) return 0;
  for (y = x->LegalIdentifiers; n>=0 && y; --n, y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_LegalIdentifiers) */

struct zx_hrxml_LegalIdentifiers_s* zx_hrxml_PersonDescriptors_POP_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x) return 0;
  y = x->LegalIdentifiers;
  if (y)
    x->LegalIdentifiers = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_LegalIdentifiers) */

void zx_hrxml_PersonDescriptors_PUSH_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_LegalIdentifiers_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LegalIdentifiers->gg.g;
  x->LegalIdentifiers = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_LegalIdentifiers) */

void zx_hrxml_PersonDescriptors_REV_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_LegalIdentifiers_s* nxt;
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x) return;
  y = x->LegalIdentifiers;
  if (!y) return;
  x->LegalIdentifiers = 0;
  while (y) {
    nxt = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n;
    y->gg.g.n = &x->LegalIdentifiers->gg.g;
    x->LegalIdentifiers = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_LegalIdentifiers) */

void zx_hrxml_PersonDescriptors_PUT_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_LegalIdentifiers_s* z)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x || !z) return;
  y = x->LegalIdentifiers;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LegalIdentifiers = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_LegalIdentifiers) */

void zx_hrxml_PersonDescriptors_ADD_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_LegalIdentifiers_s* z)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LegalIdentifiers->gg.g;
    x->LegalIdentifiers = z;
    return;
  case -1:
    y = x->LegalIdentifiers;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalIdentifiers; n > 1 && y; --n, y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_LegalIdentifiers) */

void zx_hrxml_PersonDescriptors_DEL_LegalIdentifiers(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_LegalIdentifiers_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalIdentifiers = (struct zx_hrxml_LegalIdentifiers_s*)x->LegalIdentifiers->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LegalIdentifiers_s*)x->LegalIdentifiers;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalIdentifiers; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalIdentifiers_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_DemographicDescriptors) */

int zx_hrxml_PersonDescriptors_NUM_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DemographicDescriptors; y; ++n, y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_DemographicDescriptors) */

struct zx_hrxml_DemographicDescriptors_s* zx_hrxml_PersonDescriptors_GET_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x) return 0;
  for (y = x->DemographicDescriptors; n>=0 && y; --n, y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_DemographicDescriptors) */

struct zx_hrxml_DemographicDescriptors_s* zx_hrxml_PersonDescriptors_POP_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x) return 0;
  y = x->DemographicDescriptors;
  if (y)
    x->DemographicDescriptors = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_DemographicDescriptors) */

void zx_hrxml_PersonDescriptors_PUSH_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_DemographicDescriptors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DemographicDescriptors->gg.g;
  x->DemographicDescriptors = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_DemographicDescriptors) */

void zx_hrxml_PersonDescriptors_REV_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_DemographicDescriptors_s* nxt;
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x) return;
  y = x->DemographicDescriptors;
  if (!y) return;
  x->DemographicDescriptors = 0;
  while (y) {
    nxt = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n;
    y->gg.g.n = &x->DemographicDescriptors->gg.g;
    x->DemographicDescriptors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_DemographicDescriptors) */

void zx_hrxml_PersonDescriptors_PUT_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_DemographicDescriptors_s* z)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x || !z) return;
  y = x->DemographicDescriptors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DemographicDescriptors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_DemographicDescriptors) */

void zx_hrxml_PersonDescriptors_ADD_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_DemographicDescriptors_s* z)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DemographicDescriptors->gg.g;
    x->DemographicDescriptors = z;
    return;
  case -1:
    y = x->DemographicDescriptors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DemographicDescriptors; n > 1 && y; --n, y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_DemographicDescriptors) */

void zx_hrxml_PersonDescriptors_DEL_DemographicDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_DemographicDescriptors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DemographicDescriptors = (struct zx_hrxml_DemographicDescriptors_s*)x->DemographicDescriptors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DemographicDescriptors_s*)x->DemographicDescriptors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DemographicDescriptors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DemographicDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_BiologicalDescriptors) */

int zx_hrxml_PersonDescriptors_NUM_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BiologicalDescriptors; y; ++n, y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_BiologicalDescriptors) */

struct zx_hrxml_BiologicalDescriptors_s* zx_hrxml_PersonDescriptors_GET_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x) return 0;
  for (y = x->BiologicalDescriptors; n>=0 && y; --n, y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_BiologicalDescriptors) */

struct zx_hrxml_BiologicalDescriptors_s* zx_hrxml_PersonDescriptors_POP_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x) return 0;
  y = x->BiologicalDescriptors;
  if (y)
    x->BiologicalDescriptors = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_BiologicalDescriptors) */

void zx_hrxml_PersonDescriptors_PUSH_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_BiologicalDescriptors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->BiologicalDescriptors->gg.g;
  x->BiologicalDescriptors = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_BiologicalDescriptors) */

void zx_hrxml_PersonDescriptors_REV_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_BiologicalDescriptors_s* nxt;
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x) return;
  y = x->BiologicalDescriptors;
  if (!y) return;
  x->BiologicalDescriptors = 0;
  while (y) {
    nxt = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n;
    y->gg.g.n = &x->BiologicalDescriptors->gg.g;
    x->BiologicalDescriptors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_BiologicalDescriptors) */

void zx_hrxml_PersonDescriptors_PUT_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_BiologicalDescriptors_s* z)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x || !z) return;
  y = x->BiologicalDescriptors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->BiologicalDescriptors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_BiologicalDescriptors) */

void zx_hrxml_PersonDescriptors_ADD_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_BiologicalDescriptors_s* z)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->BiologicalDescriptors->gg.g;
    x->BiologicalDescriptors = z;
    return;
  case -1:
    y = x->BiologicalDescriptors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BiologicalDescriptors; n > 1 && y; --n, y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_BiologicalDescriptors) */

void zx_hrxml_PersonDescriptors_DEL_BiologicalDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_BiologicalDescriptors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BiologicalDescriptors = (struct zx_hrxml_BiologicalDescriptors_s*)x->BiologicalDescriptors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_BiologicalDescriptors_s*)x->BiologicalDescriptors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BiologicalDescriptors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BiologicalDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_SupportingMaterials) */

int zx_hrxml_PersonDescriptors_NUM_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingMaterials; y; ++n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_PersonDescriptors_GET_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  for (y = x->SupportingMaterials; n>=0 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_PersonDescriptors_POP_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  y = x->SupportingMaterials;
  if (y)
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_SupportingMaterials) */

void zx_hrxml_PersonDescriptors_PUSH_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_SupportingMaterials_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SupportingMaterials->gg.g;
  x->SupportingMaterials = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_SupportingMaterials) */

void zx_hrxml_PersonDescriptors_REV_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* nxt;
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  y = x->SupportingMaterials;
  if (!y) return;
  x->SupportingMaterials = 0;
  while (y) {
    nxt = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
    y->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_SupportingMaterials) */

void zx_hrxml_PersonDescriptors_PUT_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  y = x->SupportingMaterials;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SupportingMaterials = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_SupportingMaterials) */

void zx_hrxml_PersonDescriptors_ADD_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = z;
    return;
  case -1:
    y = x->SupportingMaterials;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_SupportingMaterials) */

void zx_hrxml_PersonDescriptors_DEL_SupportingMaterials(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_OtherDescriptors) */

int zx_hrxml_PersonDescriptors_NUM_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherDescriptors; y; ++n, y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_OtherDescriptors) */

struct zx_hrxml_OtherDescriptors_s* zx_hrxml_PersonDescriptors_GET_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x) return 0;
  for (y = x->OtherDescriptors; n>=0 && y; --n, y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_OtherDescriptors) */

struct zx_hrxml_OtherDescriptors_s* zx_hrxml_PersonDescriptors_POP_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x) return 0;
  y = x->OtherDescriptors;
  if (y)
    x->OtherDescriptors = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_OtherDescriptors) */

void zx_hrxml_PersonDescriptors_PUSH_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_OtherDescriptors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherDescriptors->gg.g;
  x->OtherDescriptors = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_OtherDescriptors) */

void zx_hrxml_PersonDescriptors_REV_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_OtherDescriptors_s* nxt;
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x) return;
  y = x->OtherDescriptors;
  if (!y) return;
  x->OtherDescriptors = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherDescriptors->gg.g;
    x->OtherDescriptors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_OtherDescriptors) */

void zx_hrxml_PersonDescriptors_PUT_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_OtherDescriptors_s* z)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x || !z) return;
  y = x->OtherDescriptors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherDescriptors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_OtherDescriptors) */

void zx_hrxml_PersonDescriptors_ADD_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_OtherDescriptors_s* z)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherDescriptors->gg.g;
    x->OtherDescriptors = z;
    return;
  case -1:
    y = x->OtherDescriptors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherDescriptors; n > 1 && y; --n, y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_OtherDescriptors) */

void zx_hrxml_PersonDescriptors_DEL_OtherDescriptors(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_OtherDescriptors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherDescriptors = (struct zx_hrxml_OtherDescriptors_s*)x->OtherDescriptors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherDescriptors_s*)x->OtherDescriptors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherDescriptors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonDescriptors_NUM_UserArea) */

int zx_hrxml_PersonDescriptors_NUM_UserArea(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonDescriptors_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PersonDescriptors_GET_UserArea(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PersonDescriptors_POP_UserArea(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonDescriptors_PUSH_UserArea) */

void zx_hrxml_PersonDescriptors_PUSH_UserArea(struct zx_hrxml_PersonDescriptors_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PersonDescriptors_REV_UserArea) */

void zx_hrxml_PersonDescriptors_REV_UserArea(struct zx_hrxml_PersonDescriptors_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_PUT_UserArea) */

void zx_hrxml_PersonDescriptors_PUT_UserArea(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonDescriptors_ADD_UserArea) */

void zx_hrxml_PersonDescriptors_ADD_UserArea(struct zx_hrxml_PersonDescriptors_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonDescriptors_DEL_UserArea) */

void zx_hrxml_PersonDescriptors_DEL_UserArea(struct zx_hrxml_PersonDescriptors_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonId_NUM_IdValue) */

int zx_hrxml_PersonId_NUM_IdValue(struct zx_hrxml_PersonId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_PersonId_GET_IdValue(struct zx_hrxml_PersonId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_PersonId_POP_IdValue(struct zx_hrxml_PersonId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonId_PUSH_IdValue) */

void zx_hrxml_PersonId_PUSH_IdValue(struct zx_hrxml_PersonId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_PersonId_REV_IdValue) */

void zx_hrxml_PersonId_REV_IdValue(struct zx_hrxml_PersonId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonId_PUT_IdValue) */

void zx_hrxml_PersonId_PUT_IdValue(struct zx_hrxml_PersonId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonId_ADD_IdValue) */

void zx_hrxml_PersonId_ADD_IdValue(struct zx_hrxml_PersonId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonId_DEL_IdValue) */

void zx_hrxml_PersonId_DEL_IdValue(struct zx_hrxml_PersonId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PersonId_GET_idOwner) */
struct zx_str* zx_hrxml_PersonId_GET_idOwner(struct zx_hrxml_PersonId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_PersonId_PUT_idOwner) */
void zx_hrxml_PersonId_PUT_idOwner(struct zx_hrxml_PersonId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_PersonId_GET_validFrom) */
struct zx_str* zx_hrxml_PersonId_GET_validFrom(struct zx_hrxml_PersonId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_PersonId_PUT_validFrom) */
void zx_hrxml_PersonId_PUT_validFrom(struct zx_hrxml_PersonId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_PersonId_GET_validTo) */
struct zx_str* zx_hrxml_PersonId_GET_validTo(struct zx_hrxml_PersonId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_PersonId_PUT_validTo) */
void zx_hrxml_PersonId_PUT_validTo(struct zx_hrxml_PersonId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonLegalId_NUM_IdValue) */

int zx_hrxml_PersonLegalId_NUM_IdValue(struct zx_hrxml_PersonLegalId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonLegalId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_PersonLegalId_GET_IdValue(struct zx_hrxml_PersonLegalId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonLegalId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_PersonLegalId_POP_IdValue(struct zx_hrxml_PersonLegalId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonLegalId_PUSH_IdValue) */

void zx_hrxml_PersonLegalId_PUSH_IdValue(struct zx_hrxml_PersonLegalId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_PersonLegalId_REV_IdValue) */

void zx_hrxml_PersonLegalId_REV_IdValue(struct zx_hrxml_PersonLegalId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonLegalId_PUT_IdValue) */

void zx_hrxml_PersonLegalId_PUT_IdValue(struct zx_hrxml_PersonLegalId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonLegalId_ADD_IdValue) */

void zx_hrxml_PersonLegalId_ADD_IdValue(struct zx_hrxml_PersonLegalId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonLegalId_DEL_IdValue) */

void zx_hrxml_PersonLegalId_DEL_IdValue(struct zx_hrxml_PersonLegalId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PersonLegalId_GET_countryCode) */
struct zx_str* zx_hrxml_PersonLegalId_GET_countryCode(struct zx_hrxml_PersonLegalId_s* x) { return x->countryCode; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_countryCode) */
void zx_hrxml_PersonLegalId_PUT_countryCode(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->countryCode = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_documentType) */
struct zx_str* zx_hrxml_PersonLegalId_GET_documentType(struct zx_hrxml_PersonLegalId_s* x) { return x->documentType; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_documentType) */
void zx_hrxml_PersonLegalId_PUT_documentType(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->documentType = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_idOwner) */
struct zx_str* zx_hrxml_PersonLegalId_GET_idOwner(struct zx_hrxml_PersonLegalId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_idOwner) */
void zx_hrxml_PersonLegalId_PUT_idOwner(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_idSource) */
struct zx_str* zx_hrxml_PersonLegalId_GET_idSource(struct zx_hrxml_PersonLegalId_s* x) { return x->idSource; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_idSource) */
void zx_hrxml_PersonLegalId_PUT_idSource(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->idSource = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_issuingRegion) */
struct zx_str* zx_hrxml_PersonLegalId_GET_issuingRegion(struct zx_hrxml_PersonLegalId_s* x) { return x->issuingRegion; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_issuingRegion) */
void zx_hrxml_PersonLegalId_PUT_issuingRegion(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->issuingRegion = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_jurisdiction) */
struct zx_str* zx_hrxml_PersonLegalId_GET_jurisdiction(struct zx_hrxml_PersonLegalId_s* x) { return x->jurisdiction; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_jurisdiction) */
void zx_hrxml_PersonLegalId_PUT_jurisdiction(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->jurisdiction = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_validFrom) */
struct zx_str* zx_hrxml_PersonLegalId_GET_validFrom(struct zx_hrxml_PersonLegalId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_validFrom) */
void zx_hrxml_PersonLegalId_PUT_validFrom(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_PersonLegalId_GET_validTo) */
struct zx_str* zx_hrxml_PersonLegalId_GET_validTo(struct zx_hrxml_PersonLegalId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_PersonLegalId_PUT_validTo) */
void zx_hrxml_PersonLegalId_PUT_validTo(struct zx_hrxml_PersonLegalId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonMember_NUM_PersonName) */

int zx_hrxml_PersonMember_NUM_PersonName(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonMember_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_PersonMember_GET_PersonName(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_PersonMember_POP_PersonName(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_PUSH_PersonName) */

void zx_hrxml_PersonMember_PUSH_PersonName(struct zx_hrxml_PersonMember_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_PersonMember_REV_PersonName) */

void zx_hrxml_PersonMember_REV_PersonName(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonMember_PUT_PersonName) */

void zx_hrxml_PersonMember_PUT_PersonName(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonMember_ADD_PersonName) */

void zx_hrxml_PersonMember_ADD_PersonName(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonMember_DEL_PersonName) */

void zx_hrxml_PersonMember_DEL_PersonName(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonMember_NUM_PersonId) */

int zx_hrxml_PersonMember_NUM_PersonId(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonId; y; ++n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonMember_GET_PersonId) */

struct zx_hrxml_PersonId_s* zx_hrxml_PersonMember_GET_PersonId(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return 0;
  for (y = x->PersonId; n>=0 && y; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_POP_PersonId) */

struct zx_hrxml_PersonId_s* zx_hrxml_PersonMember_POP_PersonId(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return 0;
  y = x->PersonId;
  if (y)
    x->PersonId = (struct zx_hrxml_PersonId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_PUSH_PersonId) */

void zx_hrxml_PersonMember_PUSH_PersonId(struct zx_hrxml_PersonMember_s* x, struct zx_hrxml_PersonId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonId->gg.g;
  x->PersonId = z;
}

/* FUNC(zx_hrxml_PersonMember_REV_PersonId) */

void zx_hrxml_PersonMember_REV_PersonId(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonId_s* nxt;
  struct zx_hrxml_PersonId_s* y;
  if (!x) return;
  y = x->PersonId;
  if (!y) return;
  x->PersonId = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonId_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonId->gg.g;
    x->PersonId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonMember_PUT_PersonId) */

void zx_hrxml_PersonMember_PUT_PersonId(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonId_s* z)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x || !z) return;
  y = x->PersonId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonMember_ADD_PersonId) */

void zx_hrxml_PersonMember_ADD_PersonId(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonId_s* z)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonId->gg.g;
    x->PersonId = z;
    return;
  case -1:
    y = x->PersonId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonId; n > 1 && y; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonMember_DEL_PersonId) */

void zx_hrxml_PersonMember_DEL_PersonId(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonId = (struct zx_hrxml_PersonId_s*)x->PersonId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonId_s*)x->PersonId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonMember_NUM_PersonRole) */

int zx_hrxml_PersonMember_NUM_PersonRole(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonRole_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonRole; y; ++n, y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonMember_GET_PersonRole) */

struct zx_hrxml_PersonRole_s* zx_hrxml_PersonMember_GET_PersonRole(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonRole_s* y;
  if (!x) return 0;
  for (y = x->PersonRole; n>=0 && y; --n, y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_POP_PersonRole) */

struct zx_hrxml_PersonRole_s* zx_hrxml_PersonMember_POP_PersonRole(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonRole_s* y;
  if (!x) return 0;
  y = x->PersonRole;
  if (y)
    x->PersonRole = (struct zx_hrxml_PersonRole_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_PUSH_PersonRole) */

void zx_hrxml_PersonMember_PUSH_PersonRole(struct zx_hrxml_PersonMember_s* x, struct zx_hrxml_PersonRole_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonRole->gg.g;
  x->PersonRole = z;
}

/* FUNC(zx_hrxml_PersonMember_REV_PersonRole) */

void zx_hrxml_PersonMember_REV_PersonRole(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_PersonRole_s* nxt;
  struct zx_hrxml_PersonRole_s* y;
  if (!x) return;
  y = x->PersonRole;
  if (!y) return;
  x->PersonRole = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonRole_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonRole->gg.g;
    x->PersonRole = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonMember_PUT_PersonRole) */

void zx_hrxml_PersonMember_PUT_PersonRole(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonRole_s* z)
{
  struct zx_hrxml_PersonRole_s* y;
  if (!x || !z) return;
  y = x->PersonRole;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonRole = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonMember_ADD_PersonRole) */

void zx_hrxml_PersonMember_ADD_PersonRole(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_PersonRole_s* z)
{
  struct zx_hrxml_PersonRole_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonRole->gg.g;
    x->PersonRole = z;
    return;
  case -1:
    y = x->PersonRole;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonRole; n > 1 && y; --n, y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonMember_DEL_PersonRole) */

void zx_hrxml_PersonMember_DEL_PersonRole(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_PersonRole_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonRole = (struct zx_hrxml_PersonRole_s*)x->PersonRole->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonRole_s*)x->PersonRole;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonRole; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonRole_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonMember_NUM_ContactMethod) */

int zx_hrxml_PersonMember_NUM_ContactMethod(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonMember_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_PersonMember_GET_ContactMethod(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_PersonMember_POP_ContactMethod(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonMember_PUSH_ContactMethod) */

void zx_hrxml_PersonMember_PUSH_ContactMethod(struct zx_hrxml_PersonMember_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_PersonMember_REV_ContactMethod) */

void zx_hrxml_PersonMember_REV_ContactMethod(struct zx_hrxml_PersonMember_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonMember_PUT_ContactMethod) */

void zx_hrxml_PersonMember_PUT_ContactMethod(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonMember_ADD_ContactMethod) */

void zx_hrxml_PersonMember_ADD_ContactMethod(struct zx_hrxml_PersonMember_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonMember_DEL_ContactMethod) */

void zx_hrxml_PersonMember_DEL_ContactMethod(struct zx_hrxml_PersonMember_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_FormattedName) */

int zx_hrxml_PersonName_NUM_FormattedName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_FormattedName) */

struct zx_elem_s* zx_hrxml_PersonName_GET_FormattedName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_FormattedName) */

struct zx_elem_s* zx_hrxml_PersonName_POP_FormattedName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedName;
  if (y)
    x->FormattedName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_FormattedName) */

void zx_hrxml_PersonName_PUSH_FormattedName(struct zx_hrxml_PersonName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedName->g;
  x->FormattedName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_FormattedName) */

void zx_hrxml_PersonName_REV_FormattedName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedName;
  if (!y) return;
  x->FormattedName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedName->g;
    x->FormattedName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_FormattedName) */

void zx_hrxml_PersonName_PUT_FormattedName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_FormattedName) */

void zx_hrxml_PersonName_ADD_FormattedName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedName->g;
    x->FormattedName = z;
    return;
  case -1:
    y = x->FormattedName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonName_DEL_FormattedName) */

void zx_hrxml_PersonName_DEL_FormattedName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedName = (struct zx_elem_s*)x->FormattedName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_LegalName) */

int zx_hrxml_PersonName_NUM_LegalName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_LegalName) */

struct zx_elem_s* zx_hrxml_PersonName_GET_LegalName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->LegalName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_LegalName) */

struct zx_elem_s* zx_hrxml_PersonName_POP_LegalName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->LegalName;
  if (y)
    x->LegalName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_LegalName) */

void zx_hrxml_PersonName_PUSH_LegalName(struct zx_hrxml_PersonName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->LegalName->g;
  x->LegalName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_LegalName) */

void zx_hrxml_PersonName_REV_LegalName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->LegalName;
  if (!y) return;
  x->LegalName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->LegalName->g;
    x->LegalName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_LegalName) */

void zx_hrxml_PersonName_PUT_LegalName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->LegalName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->LegalName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_LegalName) */

void zx_hrxml_PersonName_ADD_LegalName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->LegalName->g;
    x->LegalName = z;
    return;
  case -1:
    y = x->LegalName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonName_DEL_LegalName) */

void zx_hrxml_PersonName_DEL_LegalName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalName = (struct zx_elem_s*)x->LegalName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->LegalName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->LegalName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_GivenName) */

int zx_hrxml_PersonName_NUM_GivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->GivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_GivenName) */

struct zx_elem_s* zx_hrxml_PersonName_GET_GivenName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->GivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_GivenName) */

struct zx_elem_s* zx_hrxml_PersonName_POP_GivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->GivenName;
  if (y)
    x->GivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_GivenName) */

void zx_hrxml_PersonName_PUSH_GivenName(struct zx_hrxml_PersonName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->GivenName->g;
  x->GivenName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_GivenName) */

void zx_hrxml_PersonName_REV_GivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->GivenName;
  if (!y) return;
  x->GivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->GivenName->g;
    x->GivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_GivenName) */

void zx_hrxml_PersonName_PUT_GivenName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->GivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->GivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_GivenName) */

void zx_hrxml_PersonName_ADD_GivenName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->GivenName->g;
    x->GivenName = z;
    return;
  case -1:
    y = x->GivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonName_DEL_GivenName) */

void zx_hrxml_PersonName_DEL_GivenName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->GivenName = (struct zx_elem_s*)x->GivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->GivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->GivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_PreferredGivenName) */

int zx_hrxml_PersonName_NUM_PreferredGivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredGivenName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_PersonName_GET_PreferredGivenName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PreferredGivenName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_PreferredGivenName) */

struct zx_elem_s* zx_hrxml_PersonName_POP_PreferredGivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PreferredGivenName;
  if (y)
    x->PreferredGivenName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_PreferredGivenName) */

void zx_hrxml_PersonName_PUSH_PreferredGivenName(struct zx_hrxml_PersonName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PreferredGivenName->g;
  x->PreferredGivenName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_PreferredGivenName) */

void zx_hrxml_PersonName_REV_PreferredGivenName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PreferredGivenName;
  if (!y) return;
  x->PreferredGivenName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_PreferredGivenName) */

void zx_hrxml_PersonName_PUT_PreferredGivenName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PreferredGivenName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PreferredGivenName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_PreferredGivenName) */

void zx_hrxml_PersonName_ADD_PreferredGivenName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PreferredGivenName->g;
    x->PreferredGivenName = z;
    return;
  case -1:
    y = x->PreferredGivenName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonName_DEL_PreferredGivenName) */

void zx_hrxml_PersonName_DEL_PreferredGivenName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredGivenName = (struct zx_elem_s*)x->PreferredGivenName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PreferredGivenName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PreferredGivenName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_MiddleName) */

int zx_hrxml_PersonName_NUM_MiddleName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MiddleName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_MiddleName) */

struct zx_elem_s* zx_hrxml_PersonName_GET_MiddleName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MiddleName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_MiddleName) */

struct zx_elem_s* zx_hrxml_PersonName_POP_MiddleName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MiddleName;
  if (y)
    x->MiddleName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_MiddleName) */

void zx_hrxml_PersonName_PUSH_MiddleName(struct zx_hrxml_PersonName_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MiddleName->g;
  x->MiddleName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_MiddleName) */

void zx_hrxml_PersonName_REV_MiddleName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MiddleName;
  if (!y) return;
  x->MiddleName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MiddleName->g;
    x->MiddleName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_MiddleName) */

void zx_hrxml_PersonName_PUT_MiddleName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MiddleName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MiddleName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_MiddleName) */

void zx_hrxml_PersonName_ADD_MiddleName(struct zx_hrxml_PersonName_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MiddleName->g;
    x->MiddleName = z;
    return;
  case -1:
    y = x->MiddleName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonName_DEL_MiddleName) */

void zx_hrxml_PersonName_DEL_MiddleName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MiddleName = (struct zx_elem_s*)x->MiddleName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MiddleName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MiddleName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_FamilyName) */

int zx_hrxml_PersonName_NUM_FamilyName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FamilyName; y; ++n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_PersonName_GET_FamilyName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  for (y = x->FamilyName; n>=0 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_FamilyName) */

struct zx_hrxml_FamilyName_s* zx_hrxml_PersonName_POP_FamilyName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return 0;
  y = x->FamilyName;
  if (y)
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_FamilyName) */

void zx_hrxml_PersonName_PUSH_FamilyName(struct zx_hrxml_PersonName_s* x, struct zx_hrxml_FamilyName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->FamilyName->gg.g;
  x->FamilyName = z;
}

/* FUNC(zx_hrxml_PersonName_REV_FamilyName) */

void zx_hrxml_PersonName_REV_FamilyName(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_FamilyName_s* nxt;
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  y = x->FamilyName;
  if (!y) return;
  x->FamilyName = 0;
  while (y) {
    nxt = (struct zx_hrxml_FamilyName_s*)y->gg.g.n;
    y->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_FamilyName) */

void zx_hrxml_PersonName_PUT_FamilyName(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  y = x->FamilyName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->FamilyName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_FamilyName) */

void zx_hrxml_PersonName_ADD_FamilyName(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_FamilyName_s* z)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->FamilyName->gg.g;
    x->FamilyName = z;
    return;
  case -1:
    y = x->FamilyName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonName_DEL_FamilyName) */

void zx_hrxml_PersonName_DEL_FamilyName(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_FamilyName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FamilyName = (struct zx_hrxml_FamilyName_s*)x->FamilyName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_FamilyName_s*)x->FamilyName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FamilyName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FamilyName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_Affix) */

int zx_hrxml_PersonName_NUM_Affix(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_Affix_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Affix; y; ++n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_PersonName_GET_Affix(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  for (y = x->Affix; n>=0 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_Affix) */

struct zx_hrxml_Affix_s* zx_hrxml_PersonName_POP_Affix(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return 0;
  y = x->Affix;
  if (y)
    x->Affix = (struct zx_hrxml_Affix_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_Affix) */

void zx_hrxml_PersonName_PUSH_Affix(struct zx_hrxml_PersonName_s* x, struct zx_hrxml_Affix_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Affix->gg.g;
  x->Affix = z;
}

/* FUNC(zx_hrxml_PersonName_REV_Affix) */

void zx_hrxml_PersonName_REV_Affix(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_Affix_s* nxt;
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  y = x->Affix;
  if (!y) return;
  x->Affix = 0;
  while (y) {
    nxt = (struct zx_hrxml_Affix_s*)y->gg.g.n;
    y->gg.g.n = &x->Affix->gg.g;
    x->Affix = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_Affix) */

void zx_hrxml_PersonName_PUT_Affix(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  y = x->Affix;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Affix = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_Affix) */

void zx_hrxml_PersonName_ADD_Affix(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_Affix_s* z)
{
  struct zx_hrxml_Affix_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Affix->gg.g;
    x->Affix = z;
    return;
  case -1:
    y = x->Affix;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonName_DEL_Affix) */

void zx_hrxml_PersonName_DEL_Affix(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_Affix_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Affix = (struct zx_hrxml_Affix_s*)x->Affix->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Affix_s*)x->Affix;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Affix; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Affix_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonName_NUM_AlternateScript) */

int zx_hrxml_PersonName_NUM_AlternateScript(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_AlternateScript_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AlternateScript; y; ++n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonName_GET_AlternateScript) */

struct zx_hrxml_AlternateScript_s* zx_hrxml_PersonName_GET_AlternateScript(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return 0;
  for (y = x->AlternateScript; n>=0 && y; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonName_POP_AlternateScript) */

struct zx_hrxml_AlternateScript_s* zx_hrxml_PersonName_POP_AlternateScript(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return 0;
  y = x->AlternateScript;
  if (y)
    x->AlternateScript = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonName_PUSH_AlternateScript) */

void zx_hrxml_PersonName_PUSH_AlternateScript(struct zx_hrxml_PersonName_s* x, struct zx_hrxml_AlternateScript_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AlternateScript->gg.g;
  x->AlternateScript = z;
}

/* FUNC(zx_hrxml_PersonName_REV_AlternateScript) */

void zx_hrxml_PersonName_REV_AlternateScript(struct zx_hrxml_PersonName_s* x)
{
  struct zx_hrxml_AlternateScript_s* nxt;
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return;
  y = x->AlternateScript;
  if (!y) return;
  x->AlternateScript = 0;
  while (y) {
    nxt = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n;
    y->gg.g.n = &x->AlternateScript->gg.g;
    x->AlternateScript = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonName_PUT_AlternateScript) */

void zx_hrxml_PersonName_PUT_AlternateScript(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_AlternateScript_s* z)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x || !z) return;
  y = x->AlternateScript;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AlternateScript = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonName_ADD_AlternateScript) */

void zx_hrxml_PersonName_ADD_AlternateScript(struct zx_hrxml_PersonName_s* x, int n, struct zx_hrxml_AlternateScript_s* z)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AlternateScript->gg.g;
    x->AlternateScript = z;
    return;
  case -1:
    y = x->AlternateScript;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AlternateScript; n > 1 && y; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonName_DEL_AlternateScript) */

void zx_hrxml_PersonName_DEL_AlternateScript(struct zx_hrxml_PersonName_s* x, int n)
{
  struct zx_hrxml_AlternateScript_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AlternateScript = (struct zx_hrxml_AlternateScript_s*)x->AlternateScript->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AlternateScript_s*)x->AlternateScript;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AlternateScript; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AlternateScript_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PersonName_GET_script) */
struct zx_str* zx_hrxml_PersonName_GET_script(struct zx_hrxml_PersonName_s* x) { return x->script; }
/* FUNC(zx_hrxml_PersonName_PUT_script) */
void zx_hrxml_PersonName_PUT_script(struct zx_hrxml_PersonName_s* x, struct zx_str* y) { x->script = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonRole_NUM_RoleName) */

int zx_hrxml_PersonRole_NUM_RoleName(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RoleName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonRole_GET_RoleName) */

struct zx_elem_s* zx_hrxml_PersonRole_GET_RoleName(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->RoleName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_POP_RoleName) */

struct zx_elem_s* zx_hrxml_PersonRole_POP_RoleName(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->RoleName;
  if (y)
    x->RoleName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_PUSH_RoleName) */

void zx_hrxml_PersonRole_PUSH_RoleName(struct zx_hrxml_PersonRole_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->RoleName->g;
  x->RoleName = z;
}

/* FUNC(zx_hrxml_PersonRole_REV_RoleName) */

void zx_hrxml_PersonRole_REV_RoleName(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->RoleName;
  if (!y) return;
  x->RoleName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->RoleName->g;
    x->RoleName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonRole_PUT_RoleName) */

void zx_hrxml_PersonRole_PUT_RoleName(struct zx_hrxml_PersonRole_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->RoleName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->RoleName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PersonRole_ADD_RoleName) */

void zx_hrxml_PersonRole_ADD_RoleName(struct zx_hrxml_PersonRole_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->RoleName->g;
    x->RoleName = z;
    return;
  case -1:
    y = x->RoleName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RoleName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PersonRole_DEL_RoleName) */

void zx_hrxml_PersonRole_DEL_RoleName(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RoleName = (struct zx_elem_s*)x->RoleName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->RoleName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RoleName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonRole_NUM_RoleId) */

int zx_hrxml_PersonRole_NUM_RoleId(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_RoleId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RoleId; y; ++n, y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonRole_GET_RoleId) */

struct zx_hrxml_RoleId_s* zx_hrxml_PersonRole_GET_RoleId(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_hrxml_RoleId_s* y;
  if (!x) return 0;
  for (y = x->RoleId; n>=0 && y; --n, y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_POP_RoleId) */

struct zx_hrxml_RoleId_s* zx_hrxml_PersonRole_POP_RoleId(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_RoleId_s* y;
  if (!x) return 0;
  y = x->RoleId;
  if (y)
    x->RoleId = (struct zx_hrxml_RoleId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_PUSH_RoleId) */

void zx_hrxml_PersonRole_PUSH_RoleId(struct zx_hrxml_PersonRole_s* x, struct zx_hrxml_RoleId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RoleId->gg.g;
  x->RoleId = z;
}

/* FUNC(zx_hrxml_PersonRole_REV_RoleId) */

void zx_hrxml_PersonRole_REV_RoleId(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_RoleId_s* nxt;
  struct zx_hrxml_RoleId_s* y;
  if (!x) return;
  y = x->RoleId;
  if (!y) return;
  x->RoleId = 0;
  while (y) {
    nxt = (struct zx_hrxml_RoleId_s*)y->gg.g.n;
    y->gg.g.n = &x->RoleId->gg.g;
    x->RoleId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonRole_PUT_RoleId) */

void zx_hrxml_PersonRole_PUT_RoleId(struct zx_hrxml_PersonRole_s* x, int n, struct zx_hrxml_RoleId_s* z)
{
  struct zx_hrxml_RoleId_s* y;
  if (!x || !z) return;
  y = x->RoleId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RoleId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonRole_ADD_RoleId) */

void zx_hrxml_PersonRole_ADD_RoleId(struct zx_hrxml_PersonRole_s* x, int n, struct zx_hrxml_RoleId_s* z)
{
  struct zx_hrxml_RoleId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RoleId->gg.g;
    x->RoleId = z;
    return;
  case -1:
    y = x->RoleId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RoleId; n > 1 && y; --n, y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonRole_DEL_RoleId) */

void zx_hrxml_PersonRole_DEL_RoleId(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_hrxml_RoleId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RoleId = (struct zx_hrxml_RoleId_s*)x->RoleId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RoleId_s*)x->RoleId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RoleId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RoleId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonRole_NUM_Description) */

int zx_hrxml_PersonRole_NUM_Description(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonRole_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_PersonRole_GET_Description(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_PersonRole_POP_Description(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonRole_PUSH_Description) */

void zx_hrxml_PersonRole_PUSH_Description(struct zx_hrxml_PersonRole_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_PersonRole_REV_Description) */

void zx_hrxml_PersonRole_REV_Description(struct zx_hrxml_PersonRole_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonRole_PUT_Description) */

void zx_hrxml_PersonRole_PUT_Description(struct zx_hrxml_PersonRole_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonRole_ADD_Description) */

void zx_hrxml_PersonRole_ADD_Description(struct zx_hrxml_PersonRole_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonRole_DEL_Description) */

void zx_hrxml_PersonRole_DEL_Description(struct zx_hrxml_PersonRole_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PersonRole_GET_leader) */
struct zx_str* zx_hrxml_PersonRole_GET_leader(struct zx_hrxml_PersonRole_s* x) { return x->leader; }
/* FUNC(zx_hrxml_PersonRole_PUT_leader) */
void zx_hrxml_PersonRole_PUT_leader(struct zx_hrxml_PersonRole_s* x, struct zx_str* y) { x->leader = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonalData_NUM_PersonId) */

int zx_hrxml_PersonalData_NUM_PersonId(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonId; y; ++n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonalData_GET_PersonId) */

struct zx_hrxml_PersonId_s* zx_hrxml_PersonalData_GET_PersonId(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return 0;
  for (y = x->PersonId; n>=0 && y; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_POP_PersonId) */

struct zx_hrxml_PersonId_s* zx_hrxml_PersonalData_POP_PersonId(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return 0;
  y = x->PersonId;
  if (y)
    x->PersonId = (struct zx_hrxml_PersonId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_PUSH_PersonId) */

void zx_hrxml_PersonalData_PUSH_PersonId(struct zx_hrxml_PersonalData_s* x, struct zx_hrxml_PersonId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonId->gg.g;
  x->PersonId = z;
}

/* FUNC(zx_hrxml_PersonalData_REV_PersonId) */

void zx_hrxml_PersonalData_REV_PersonId(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonId_s* nxt;
  struct zx_hrxml_PersonId_s* y;
  if (!x) return;
  y = x->PersonId;
  if (!y) return;
  x->PersonId = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonId_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonId->gg.g;
    x->PersonId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonalData_PUT_PersonId) */

void zx_hrxml_PersonalData_PUT_PersonId(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonId_s* z)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x || !z) return;
  y = x->PersonId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonalData_ADD_PersonId) */

void zx_hrxml_PersonalData_ADD_PersonId(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonId_s* z)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonId->gg.g;
    x->PersonId = z;
    return;
  case -1:
    y = x->PersonId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonId; n > 1 && y; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonalData_DEL_PersonId) */

void zx_hrxml_PersonalData_DEL_PersonId(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonId = (struct zx_hrxml_PersonId_s*)x->PersonId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonId_s*)x->PersonId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonalData_NUM_PersonName) */

int zx_hrxml_PersonalData_NUM_PersonName(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonalData_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_PersonalData_GET_PersonName(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_PersonalData_POP_PersonName(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_PUSH_PersonName) */

void zx_hrxml_PersonalData_PUSH_PersonName(struct zx_hrxml_PersonalData_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_PersonalData_REV_PersonName) */

void zx_hrxml_PersonalData_REV_PersonName(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonalData_PUT_PersonName) */

void zx_hrxml_PersonalData_PUT_PersonName(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonalData_ADD_PersonName) */

void zx_hrxml_PersonalData_ADD_PersonName(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonalData_DEL_PersonName) */

void zx_hrxml_PersonalData_DEL_PersonName(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonalData_NUM_ContactMethod) */

int zx_hrxml_PersonalData_NUM_ContactMethod(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonalData_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_PersonalData_GET_ContactMethod(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_PersonalData_POP_ContactMethod(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_PUSH_ContactMethod) */

void zx_hrxml_PersonalData_PUSH_ContactMethod(struct zx_hrxml_PersonalData_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_PersonalData_REV_ContactMethod) */

void zx_hrxml_PersonalData_REV_ContactMethod(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonalData_PUT_ContactMethod) */

void zx_hrxml_PersonalData_PUT_ContactMethod(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonalData_ADD_ContactMethod) */

void zx_hrxml_PersonalData_ADD_ContactMethod(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonalData_DEL_ContactMethod) */

void zx_hrxml_PersonalData_DEL_ContactMethod(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonalData_NUM_PersonDescriptors) */

int zx_hrxml_PersonalData_NUM_PersonDescriptors(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonDescriptors; y; ++n, y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonalData_GET_PersonDescriptors) */

struct zx_hrxml_PersonDescriptors_s* zx_hrxml_PersonalData_GET_PersonDescriptors(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x) return 0;
  for (y = x->PersonDescriptors; n>=0 && y; --n, y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_POP_PersonDescriptors) */

struct zx_hrxml_PersonDescriptors_s* zx_hrxml_PersonalData_POP_PersonDescriptors(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x) return 0;
  y = x->PersonDescriptors;
  if (y)
    x->PersonDescriptors = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_PUSH_PersonDescriptors) */

void zx_hrxml_PersonalData_PUSH_PersonDescriptors(struct zx_hrxml_PersonalData_s* x, struct zx_hrxml_PersonDescriptors_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonDescriptors->gg.g;
  x->PersonDescriptors = z;
}

/* FUNC(zx_hrxml_PersonalData_REV_PersonDescriptors) */

void zx_hrxml_PersonalData_REV_PersonDescriptors(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_PersonDescriptors_s* nxt;
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x) return;
  y = x->PersonDescriptors;
  if (!y) return;
  x->PersonDescriptors = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonDescriptors->gg.g;
    x->PersonDescriptors = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonalData_PUT_PersonDescriptors) */

void zx_hrxml_PersonalData_PUT_PersonDescriptors(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonDescriptors_s* z)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x || !z) return;
  y = x->PersonDescriptors;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonDescriptors = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonalData_ADD_PersonDescriptors) */

void zx_hrxml_PersonalData_ADD_PersonDescriptors(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_PersonDescriptors_s* z)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonDescriptors->gg.g;
    x->PersonDescriptors = z;
    return;
  case -1:
    y = x->PersonDescriptors;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonDescriptors; n > 1 && y; --n, y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonalData_DEL_PersonDescriptors) */

void zx_hrxml_PersonalData_DEL_PersonDescriptors(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_PersonDescriptors_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonDescriptors = (struct zx_hrxml_PersonDescriptors_s*)x->PersonDescriptors->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonDescriptors_s*)x->PersonDescriptors;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonDescriptors; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonDescriptors_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PersonalData_NUM_UserArea) */

int zx_hrxml_PersonalData_NUM_UserArea(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PersonalData_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PersonalData_GET_UserArea(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PersonalData_POP_UserArea(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PersonalData_PUSH_UserArea) */

void zx_hrxml_PersonalData_PUSH_UserArea(struct zx_hrxml_PersonalData_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PersonalData_REV_UserArea) */

void zx_hrxml_PersonalData_REV_UserArea(struct zx_hrxml_PersonalData_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PersonalData_PUT_UserArea) */

void zx_hrxml_PersonalData_PUT_UserArea(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PersonalData_ADD_UserArea) */

void zx_hrxml_PersonalData_ADD_UserArea(struct zx_hrxml_PersonalData_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PersonalData_DEL_UserArea) */

void zx_hrxml_PersonalData_DEL_UserArea(struct zx_hrxml_PersonalData_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_Id) */

int zx_hrxml_PhysicalLocation_NUM_Id(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PhysicalLocation_GET_Id(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PhysicalLocation_POP_Id(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_Id) */

void zx_hrxml_PhysicalLocation_PUSH_Id(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_Id) */

void zx_hrxml_PhysicalLocation_REV_Id(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_Id) */

void zx_hrxml_PhysicalLocation_PUT_Id(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_Id) */

void zx_hrxml_PhysicalLocation_ADD_Id(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_Id) */

void zx_hrxml_PhysicalLocation_DEL_Id(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_Name) */

int zx_hrxml_PhysicalLocation_NUM_Name(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_Name) */

struct zx_elem_s* zx_hrxml_PhysicalLocation_GET_Name(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_Name) */

struct zx_elem_s* zx_hrxml_PhysicalLocation_POP_Name(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_Name) */

void zx_hrxml_PhysicalLocation_PUSH_Name(struct zx_hrxml_PhysicalLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_Name) */

void zx_hrxml_PhysicalLocation_REV_Name(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_Name) */

void zx_hrxml_PhysicalLocation_PUT_Name(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_Name) */

void zx_hrxml_PhysicalLocation_ADD_Name(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_Name) */

void zx_hrxml_PhysicalLocation_DEL_Name(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_EffectiveDate) */

int zx_hrxml_PhysicalLocation_NUM_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EffectiveDate; y; ++n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_PhysicalLocation_GET_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  for (y = x->EffectiveDate; n>=0 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_PhysicalLocation_POP_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  y = x->EffectiveDate;
  if (y)
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_EffectiveDate) */

void zx_hrxml_PhysicalLocation_PUSH_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_EffectiveDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EffectiveDate->gg.g;
  x->EffectiveDate = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_EffectiveDate) */

void zx_hrxml_PhysicalLocation_REV_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_EffectiveDate_s* nxt;
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  y = x->EffectiveDate;
  if (!y) return;
  x->EffectiveDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_EffectiveDate) */

void zx_hrxml_PhysicalLocation_PUT_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  y = x->EffectiveDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EffectiveDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_EffectiveDate) */

void zx_hrxml_PhysicalLocation_ADD_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = z;
    return;
  case -1:
    y = x->EffectiveDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_EffectiveDate) */

void zx_hrxml_PhysicalLocation_DEL_EffectiveDate(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_SpatialLocation) */

int zx_hrxml_PhysicalLocation_NUM_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SpatialLocation; y; ++n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_SpatialLocation) */

struct zx_hrxml_SpatialLocation_s* zx_hrxml_PhysicalLocation_GET_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return 0;
  for (y = x->SpatialLocation; n>=0 && y; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_SpatialLocation) */

struct zx_hrxml_SpatialLocation_s* zx_hrxml_PhysicalLocation_POP_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return 0;
  y = x->SpatialLocation;
  if (y)
    x->SpatialLocation = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_SpatialLocation) */

void zx_hrxml_PhysicalLocation_PUSH_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_SpatialLocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SpatialLocation->gg.g;
  x->SpatialLocation = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_SpatialLocation) */

void zx_hrxml_PhysicalLocation_REV_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* nxt;
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return;
  y = x->SpatialLocation;
  if (!y) return;
  x->SpatialLocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n;
    y->gg.g.n = &x->SpatialLocation->gg.g;
    x->SpatialLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_SpatialLocation) */

void zx_hrxml_PhysicalLocation_PUT_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_SpatialLocation_s* z)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x || !z) return;
  y = x->SpatialLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SpatialLocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_SpatialLocation) */

void zx_hrxml_PhysicalLocation_ADD_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_SpatialLocation_s* z)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SpatialLocation->gg.g;
    x->SpatialLocation = z;
    return;
  case -1:
    y = x->SpatialLocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpatialLocation; n > 1 && y; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_SpatialLocation) */

void zx_hrxml_PhysicalLocation_DEL_SpatialLocation(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SpatialLocation = (struct zx_hrxml_SpatialLocation_s*)x->SpatialLocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SpatialLocation_s*)x->SpatialLocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpatialLocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_TravelDirections) */

int zx_hrxml_PhysicalLocation_NUM_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TravelDirections; y; ++n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_PhysicalLocation_GET_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  for (y = x->TravelDirections; n>=0 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_PhysicalLocation_POP_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  y = x->TravelDirections;
  if (y)
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_TravelDirections) */

void zx_hrxml_PhysicalLocation_PUSH_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_TravelDirections_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TravelDirections->gg.g;
  x->TravelDirections = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_TravelDirections) */

void zx_hrxml_PhysicalLocation_REV_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* nxt;
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  y = x->TravelDirections;
  if (!y) return;
  x->TravelDirections = 0;
  while (y) {
    nxt = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
    y->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_TravelDirections) */

void zx_hrxml_PhysicalLocation_PUT_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  y = x->TravelDirections;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TravelDirections = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_TravelDirections) */

void zx_hrxml_PhysicalLocation_ADD_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = z;
    return;
  case -1:
    y = x->TravelDirections;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_TravelDirections) */

void zx_hrxml_PhysicalLocation_DEL_TravelDirections(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_PostalAddress) */

int zx_hrxml_PhysicalLocation_NUM_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalAddress; y; ++n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_PhysicalLocation_GET_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  for (y = x->PostalAddress; n>=0 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_PhysicalLocation_POP_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  y = x->PostalAddress;
  if (y)
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_PostalAddress) */

void zx_hrxml_PhysicalLocation_PUSH_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_PostalAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PostalAddress->gg.g;
  x->PostalAddress = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_PostalAddress) */

void zx_hrxml_PhysicalLocation_REV_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* nxt;
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  y = x->PostalAddress;
  if (!y) return;
  x->PostalAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_PostalAddress) */

void zx_hrxml_PhysicalLocation_PUT_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  y = x->PostalAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PostalAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_PostalAddress) */

void zx_hrxml_PhysicalLocation_ADD_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = z;
    return;
  case -1:
    y = x->PostalAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_PostalAddress) */

void zx_hrxml_PhysicalLocation_DEL_PostalAddress(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_Area) */

int zx_hrxml_PhysicalLocation_NUM_Area(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Area; y; ++n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_Area) */

struct zx_hrxml_Area_s* zx_hrxml_PhysicalLocation_GET_Area(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  for (y = x->Area; n>=0 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_Area) */

struct zx_hrxml_Area_s* zx_hrxml_PhysicalLocation_POP_Area(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  y = x->Area;
  if (y)
    x->Area = (struct zx_hrxml_Area_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_Area) */

void zx_hrxml_PhysicalLocation_PUSH_Area(struct zx_hrxml_PhysicalLocation_s* x, struct zx_hrxml_Area_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Area->gg.g;
  x->Area = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_Area) */

void zx_hrxml_PhysicalLocation_REV_Area(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* nxt;
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  y = x->Area;
  if (!y) return;
  x->Area = 0;
  while (y) {
    nxt = (struct zx_hrxml_Area_s*)y->gg.g.n;
    y->gg.g.n = &x->Area->gg.g;
    x->Area = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_Area) */

void zx_hrxml_PhysicalLocation_PUT_Area(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  y = x->Area;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Area = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_Area) */

void zx_hrxml_PhysicalLocation_ADD_Area(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Area->gg.g;
    x->Area = z;
    return;
  case -1:
    y = x->Area;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_Area) */

void zx_hrxml_PhysicalLocation_DEL_Area(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Area = (struct zx_hrxml_Area_s*)x->Area->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Area_s*)x->Area;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PhysicalLocation_NUM_Comments) */

int zx_hrxml_PhysicalLocation_NUM_Comments(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PhysicalLocation_GET_Comments) */

struct zx_elem_s* zx_hrxml_PhysicalLocation_GET_Comments(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_POP_Comments) */

struct zx_elem_s* zx_hrxml_PhysicalLocation_POP_Comments(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PhysicalLocation_PUSH_Comments) */

void zx_hrxml_PhysicalLocation_PUSH_Comments(struct zx_hrxml_PhysicalLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_PhysicalLocation_REV_Comments) */

void zx_hrxml_PhysicalLocation_REV_Comments(struct zx_hrxml_PhysicalLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_PUT_Comments) */

void zx_hrxml_PhysicalLocation_PUT_Comments(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PhysicalLocation_ADD_Comments) */

void zx_hrxml_PhysicalLocation_ADD_Comments(struct zx_hrxml_PhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PhysicalLocation_DEL_Comments) */

void zx_hrxml_PhysicalLocation_DEL_Comments(struct zx_hrxml_PhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Title) */

int zx_hrxml_PositionHistory_NUM_Title(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Title) */

struct zx_elem_s* zx_hrxml_PositionHistory_GET_Title(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Title) */

struct zx_elem_s* zx_hrxml_PositionHistory_POP_Title(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Title) */

void zx_hrxml_PositionHistory_PUSH_Title(struct zx_hrxml_PositionHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Title) */

void zx_hrxml_PositionHistory_REV_Title(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Title) */

void zx_hrxml_PositionHistory_PUT_Title(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Title) */

void zx_hrxml_PositionHistory_ADD_Title(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Title) */

void zx_hrxml_PositionHistory_DEL_Title(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_OrgName) */

int zx_hrxml_PositionHistory_NUM_OrgName(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrgName; y; ++n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_OrgName) */

struct zx_hrxml_OrgName_s* zx_hrxml_PositionHistory_GET_OrgName(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return 0;
  for (y = x->OrgName; n>=0 && y; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_OrgName) */

struct zx_hrxml_OrgName_s* zx_hrxml_PositionHistory_POP_OrgName(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return 0;
  y = x->OrgName;
  if (y)
    x->OrgName = (struct zx_hrxml_OrgName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_OrgName) */

void zx_hrxml_PositionHistory_PUSH_OrgName(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_OrgName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrgName->gg.g;
  x->OrgName = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_OrgName) */

void zx_hrxml_PositionHistory_REV_OrgName(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgName_s* nxt;
  struct zx_hrxml_OrgName_s* y;
  if (!x) return;
  y = x->OrgName;
  if (!y) return;
  x->OrgName = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrgName_s*)y->gg.g.n;
    y->gg.g.n = &x->OrgName->gg.g;
    x->OrgName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_OrgName) */

void zx_hrxml_PositionHistory_PUT_OrgName(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgName_s* z)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x || !z) return;
  y = x->OrgName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrgName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_OrgName) */

void zx_hrxml_PositionHistory_ADD_OrgName(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgName_s* z)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrgName->gg.g;
    x->OrgName = z;
    return;
  case -1:
    y = x->OrgName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgName; n > 1 && y; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_OrgName) */

void zx_hrxml_PositionHistory_DEL_OrgName(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrgName = (struct zx_hrxml_OrgName_s*)x->OrgName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrgName_s*)x->OrgName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_OrgInfo) */

int zx_hrxml_PositionHistory_NUM_OrgInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrgInfo; y; ++n, y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_OrgInfo) */

struct zx_hrxml_OrgInfo_s* zx_hrxml_PositionHistory_GET_OrgInfo(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgInfo_s* y;
  if (!x) return 0;
  for (y = x->OrgInfo; n>=0 && y; --n, y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_OrgInfo) */

struct zx_hrxml_OrgInfo_s* zx_hrxml_PositionHistory_POP_OrgInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgInfo_s* y;
  if (!x) return 0;
  y = x->OrgInfo;
  if (y)
    x->OrgInfo = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_OrgInfo) */

void zx_hrxml_PositionHistory_PUSH_OrgInfo(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_OrgInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrgInfo->gg.g;
  x->OrgInfo = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_OrgInfo) */

void zx_hrxml_PositionHistory_REV_OrgInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgInfo_s* nxt;
  struct zx_hrxml_OrgInfo_s* y;
  if (!x) return;
  y = x->OrgInfo;
  if (!y) return;
  x->OrgInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->OrgInfo->gg.g;
    x->OrgInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_OrgInfo) */

void zx_hrxml_PositionHistory_PUT_OrgInfo(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgInfo_s* z)
{
  struct zx_hrxml_OrgInfo_s* y;
  if (!x || !z) return;
  y = x->OrgInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrgInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_OrgInfo) */

void zx_hrxml_PositionHistory_ADD_OrgInfo(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgInfo_s* z)
{
  struct zx_hrxml_OrgInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrgInfo->gg.g;
    x->OrgInfo = z;
    return;
  case -1:
    y = x->OrgInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgInfo; n > 1 && y; --n, y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_OrgInfo) */

void zx_hrxml_PositionHistory_DEL_OrgInfo(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrgInfo = (struct zx_hrxml_OrgInfo_s*)x->OrgInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrgInfo_s*)x->OrgInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_OrgIndustry) */

int zx_hrxml_PositionHistory_NUM_OrgIndustry(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgIndustry_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrgIndustry; y; ++n, y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_OrgIndustry) */

struct zx_hrxml_OrgIndustry_s* zx_hrxml_PositionHistory_GET_OrgIndustry(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x) return 0;
  for (y = x->OrgIndustry; n>=0 && y; --n, y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_OrgIndustry) */

struct zx_hrxml_OrgIndustry_s* zx_hrxml_PositionHistory_POP_OrgIndustry(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x) return 0;
  y = x->OrgIndustry;
  if (y)
    x->OrgIndustry = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_OrgIndustry) */

void zx_hrxml_PositionHistory_PUSH_OrgIndustry(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_OrgIndustry_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrgIndustry->gg.g;
  x->OrgIndustry = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_OrgIndustry) */

void zx_hrxml_PositionHistory_REV_OrgIndustry(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_OrgIndustry_s* nxt;
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x) return;
  y = x->OrgIndustry;
  if (!y) return;
  x->OrgIndustry = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n;
    y->gg.g.n = &x->OrgIndustry->gg.g;
    x->OrgIndustry = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_OrgIndustry) */

void zx_hrxml_PositionHistory_PUT_OrgIndustry(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgIndustry_s* z)
{
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x || !z) return;
  y = x->OrgIndustry;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrgIndustry = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_OrgIndustry) */

void zx_hrxml_PositionHistory_ADD_OrgIndustry(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_OrgIndustry_s* z)
{
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrgIndustry->gg.g;
    x->OrgIndustry = z;
    return;
  case -1:
    y = x->OrgIndustry;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgIndustry; n > 1 && y; --n, y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_OrgIndustry) */

void zx_hrxml_PositionHistory_DEL_OrgIndustry(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_OrgIndustry_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrgIndustry = (struct zx_hrxml_OrgIndustry_s*)x->OrgIndustry->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrgIndustry_s*)x->OrgIndustry;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrgIndustry; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrgIndustry_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_OrgSize) */

int zx_hrxml_PositionHistory_NUM_OrgSize(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrgSize; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_OrgSize) */

struct zx_elem_s* zx_hrxml_PositionHistory_GET_OrgSize(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrgSize; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_OrgSize) */

struct zx_elem_s* zx_hrxml_PositionHistory_POP_OrgSize(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrgSize;
  if (y)
    x->OrgSize = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_OrgSize) */

void zx_hrxml_PositionHistory_PUSH_OrgSize(struct zx_hrxml_PositionHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrgSize->g;
  x->OrgSize = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_OrgSize) */

void zx_hrxml_PositionHistory_REV_OrgSize(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrgSize;
  if (!y) return;
  x->OrgSize = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrgSize->g;
    x->OrgSize = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_OrgSize) */

void zx_hrxml_PositionHistory_PUT_OrgSize(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrgSize;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrgSize = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_OrgSize) */

void zx_hrxml_PositionHistory_ADD_OrgSize(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrgSize->g;
    x->OrgSize = z;
    return;
  case -1:
    y = x->OrgSize;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrgSize; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_OrgSize) */

void zx_hrxml_PositionHistory_DEL_OrgSize(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrgSize = (struct zx_elem_s*)x->OrgSize->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrgSize;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrgSize; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Description) */

int zx_hrxml_PositionHistory_NUM_Description(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_PositionHistory_GET_Description(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_PositionHistory_POP_Description(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Description) */

void zx_hrxml_PositionHistory_PUSH_Description(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Description) */

void zx_hrxml_PositionHistory_REV_Description(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Description) */

void zx_hrxml_PositionHistory_PUT_Description(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Description) */

void zx_hrxml_PositionHistory_ADD_Description(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Description) */

void zx_hrxml_PositionHistory_DEL_Description(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_StartDate) */

int zx_hrxml_PositionHistory_NUM_StartDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_PositionHistory_GET_StartDate(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_PositionHistory_POP_StartDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_StartDate) */

void zx_hrxml_PositionHistory_PUSH_StartDate(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_StartDate) */

void zx_hrxml_PositionHistory_REV_StartDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_StartDate) */

void zx_hrxml_PositionHistory_PUT_StartDate(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_StartDate) */

void zx_hrxml_PositionHistory_ADD_StartDate(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_StartDate) */

void zx_hrxml_PositionHistory_DEL_StartDate(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_EndDate) */

int zx_hrxml_PositionHistory_NUM_EndDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_PositionHistory_GET_EndDate(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_PositionHistory_POP_EndDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_EndDate) */

void zx_hrxml_PositionHistory_PUSH_EndDate(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_EndDate) */

void zx_hrxml_PositionHistory_REV_EndDate(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_EndDate) */

void zx_hrxml_PositionHistory_PUT_EndDate(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_EndDate) */

void zx_hrxml_PositionHistory_ADD_EndDate(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_EndDate) */

void zx_hrxml_PositionHistory_DEL_EndDate(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Compensation) */

int zx_hrxml_PositionHistory_NUM_Compensation(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Compensation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Compensation; y; ++n, y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Compensation) */

struct zx_hrxml_Compensation_s* zx_hrxml_PositionHistory_GET_Compensation(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Compensation_s* y;
  if (!x) return 0;
  for (y = x->Compensation; n>=0 && y; --n, y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Compensation) */

struct zx_hrxml_Compensation_s* zx_hrxml_PositionHistory_POP_Compensation(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Compensation_s* y;
  if (!x) return 0;
  y = x->Compensation;
  if (y)
    x->Compensation = (struct zx_hrxml_Compensation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Compensation) */

void zx_hrxml_PositionHistory_PUSH_Compensation(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_Compensation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Compensation->gg.g;
  x->Compensation = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Compensation) */

void zx_hrxml_PositionHistory_REV_Compensation(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Compensation_s* nxt;
  struct zx_hrxml_Compensation_s* y;
  if (!x) return;
  y = x->Compensation;
  if (!y) return;
  x->Compensation = 0;
  while (y) {
    nxt = (struct zx_hrxml_Compensation_s*)y->gg.g.n;
    y->gg.g.n = &x->Compensation->gg.g;
    x->Compensation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Compensation) */

void zx_hrxml_PositionHistory_PUT_Compensation(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Compensation_s* z)
{
  struct zx_hrxml_Compensation_s* y;
  if (!x || !z) return;
  y = x->Compensation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Compensation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Compensation) */

void zx_hrxml_PositionHistory_ADD_Compensation(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Compensation_s* z)
{
  struct zx_hrxml_Compensation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Compensation->gg.g;
    x->Compensation = z;
    return;
  case -1:
    y = x->Compensation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Compensation; n > 1 && y; --n, y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Compensation) */

void zx_hrxml_PositionHistory_DEL_Compensation(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Compensation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Compensation = (struct zx_hrxml_Compensation_s*)x->Compensation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Compensation_s*)x->Compensation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Compensation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Compensation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Comments) */

int zx_hrxml_PositionHistory_NUM_Comments(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Comments) */

struct zx_elem_s* zx_hrxml_PositionHistory_GET_Comments(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Comments) */

struct zx_elem_s* zx_hrxml_PositionHistory_POP_Comments(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Comments) */

void zx_hrxml_PositionHistory_PUSH_Comments(struct zx_hrxml_PositionHistory_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Comments) */

void zx_hrxml_PositionHistory_REV_Comments(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Comments) */

void zx_hrxml_PositionHistory_PUT_Comments(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Comments) */

void zx_hrxml_PositionHistory_ADD_Comments(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Comments) */

void zx_hrxml_PositionHistory_DEL_Comments(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Verification) */

int zx_hrxml_PositionHistory_NUM_Verification(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Verification_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Verification; y; ++n, y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Verification) */

struct zx_hrxml_Verification_s* zx_hrxml_PositionHistory_GET_Verification(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Verification_s* y;
  if (!x) return 0;
  for (y = x->Verification; n>=0 && y; --n, y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Verification) */

struct zx_hrxml_Verification_s* zx_hrxml_PositionHistory_POP_Verification(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Verification_s* y;
  if (!x) return 0;
  y = x->Verification;
  if (y)
    x->Verification = (struct zx_hrxml_Verification_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Verification) */

void zx_hrxml_PositionHistory_PUSH_Verification(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_Verification_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Verification->gg.g;
  x->Verification = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Verification) */

void zx_hrxml_PositionHistory_REV_Verification(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Verification_s* nxt;
  struct zx_hrxml_Verification_s* y;
  if (!x) return;
  y = x->Verification;
  if (!y) return;
  x->Verification = 0;
  while (y) {
    nxt = (struct zx_hrxml_Verification_s*)y->gg.g.n;
    y->gg.g.n = &x->Verification->gg.g;
    x->Verification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Verification) */

void zx_hrxml_PositionHistory_PUT_Verification(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Verification_s* z)
{
  struct zx_hrxml_Verification_s* y;
  if (!x || !z) return;
  y = x->Verification;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Verification = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Verification) */

void zx_hrxml_PositionHistory_ADD_Verification(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Verification_s* z)
{
  struct zx_hrxml_Verification_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Verification->gg.g;
    x->Verification = z;
    return;
  case -1:
    y = x->Verification;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Verification; n > 1 && y; --n, y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Verification) */

void zx_hrxml_PositionHistory_DEL_Verification(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Verification_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Verification = (struct zx_hrxml_Verification_s*)x->Verification->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Verification_s*)x->Verification;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Verification; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Verification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_JobLevelInfo) */

int zx_hrxml_PositionHistory_NUM_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobLevelInfo; y; ++n, y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_JobLevelInfo) */

struct zx_hrxml_JobLevelInfo_s* zx_hrxml_PositionHistory_GET_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x) return 0;
  for (y = x->JobLevelInfo; n>=0 && y; --n, y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_JobLevelInfo) */

struct zx_hrxml_JobLevelInfo_s* zx_hrxml_PositionHistory_POP_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x) return 0;
  y = x->JobLevelInfo;
  if (y)
    x->JobLevelInfo = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_JobLevelInfo) */

void zx_hrxml_PositionHistory_PUSH_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_JobLevelInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->JobLevelInfo->gg.g;
  x->JobLevelInfo = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_JobLevelInfo) */

void zx_hrxml_PositionHistory_REV_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobLevelInfo_s* nxt;
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x) return;
  y = x->JobLevelInfo;
  if (!y) return;
  x->JobLevelInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->JobLevelInfo->gg.g;
    x->JobLevelInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_JobLevelInfo) */

void zx_hrxml_PositionHistory_PUT_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_JobLevelInfo_s* z)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x || !z) return;
  y = x->JobLevelInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->JobLevelInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_JobLevelInfo) */

void zx_hrxml_PositionHistory_ADD_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_JobLevelInfo_s* z)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->JobLevelInfo->gg.g;
    x->JobLevelInfo = z;
    return;
  case -1:
    y = x->JobLevelInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobLevelInfo; n > 1 && y; --n, y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_JobLevelInfo) */

void zx_hrxml_PositionHistory_DEL_JobLevelInfo(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_JobLevelInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobLevelInfo = (struct zx_hrxml_JobLevelInfo_s*)x->JobLevelInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_JobLevelInfo_s*)x->JobLevelInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobLevelInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobLevelInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_JobCategory) */

int zx_hrxml_PositionHistory_NUM_JobCategory(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobCategory; y; ++n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PositionHistory_GET_JobCategory(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  for (y = x->JobCategory; n>=0 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PositionHistory_POP_JobCategory(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  y = x->JobCategory;
  if (y)
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_JobCategory) */

void zx_hrxml_PositionHistory_PUSH_JobCategory(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_JobCategory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->JobCategory->gg.g;
  x->JobCategory = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_JobCategory) */

void zx_hrxml_PositionHistory_REV_JobCategory(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_JobCategory_s* nxt;
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  y = x->JobCategory;
  if (!y) return;
  x->JobCategory = 0;
  while (y) {
    nxt = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
    y->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_JobCategory) */

void zx_hrxml_PositionHistory_PUT_JobCategory(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  y = x->JobCategory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->JobCategory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_JobCategory) */

void zx_hrxml_PositionHistory_ADD_JobCategory(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = z;
    return;
  case -1:
    y = x->JobCategory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_JobCategory) */

void zx_hrxml_PositionHistory_DEL_JobCategory(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)x->JobCategory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_JobCategory_s*)x->JobCategory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_Competency) */

int zx_hrxml_PositionHistory_NUM_Competency(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Competency_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Competency; y; ++n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PositionHistory_GET_Competency(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  for (y = x->Competency; n>=0 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PositionHistory_POP_Competency(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  y = x->Competency;
  if (y)
    x->Competency = (struct zx_hrxml_Competency_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_Competency) */

void zx_hrxml_PositionHistory_PUSH_Competency(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_Competency_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Competency->gg.g;
  x->Competency = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_Competency) */

void zx_hrxml_PositionHistory_REV_Competency(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_Competency_s* nxt;
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  y = x->Competency;
  if (!y) return;
  x->Competency = 0;
  while (y) {
    nxt = (struct zx_hrxml_Competency_s*)y->gg.g.n;
    y->gg.g.n = &x->Competency->gg.g;
    x->Competency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_Competency) */

void zx_hrxml_PositionHistory_PUT_Competency(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  y = x->Competency;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Competency = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_Competency) */

void zx_hrxml_PositionHistory_ADD_Competency(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Competency->gg.g;
    x->Competency = z;
    return;
  case -1:
    y = x->Competency;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_Competency) */

void zx_hrxml_PositionHistory_DEL_Competency(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Competency = (struct zx_hrxml_Competency_s*)x->Competency->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Competency_s*)x->Competency;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionHistory_NUM_UserArea) */

int zx_hrxml_PositionHistory_NUM_UserArea(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionHistory_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PositionHistory_GET_UserArea(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PositionHistory_POP_UserArea(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionHistory_PUSH_UserArea) */

void zx_hrxml_PositionHistory_PUSH_UserArea(struct zx_hrxml_PositionHistory_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PositionHistory_REV_UserArea) */

void zx_hrxml_PositionHistory_REV_UserArea(struct zx_hrxml_PositionHistory_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionHistory_PUT_UserArea) */

void zx_hrxml_PositionHistory_PUT_UserArea(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionHistory_ADD_UserArea) */

void zx_hrxml_PositionHistory_ADD_UserArea(struct zx_hrxml_PositionHistory_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionHistory_DEL_UserArea) */

void zx_hrxml_PositionHistory_DEL_UserArea(struct zx_hrxml_PositionHistory_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PositionHistory_GET_currentEmployer) */
struct zx_str* zx_hrxml_PositionHistory_GET_currentEmployer(struct zx_hrxml_PositionHistory_s* x) { return x->currentEmployer; }
/* FUNC(zx_hrxml_PositionHistory_PUT_currentEmployer) */
void zx_hrxml_PositionHistory_PUT_currentEmployer(struct zx_hrxml_PositionHistory_s* x, struct zx_str* y) { x->currentEmployer = y; }
/* FUNC(zx_hrxml_PositionHistory_GET_positionType) */
struct zx_str* zx_hrxml_PositionHistory_GET_positionType(struct zx_hrxml_PositionHistory_s* x) { return x->positionType; }
/* FUNC(zx_hrxml_PositionHistory_PUT_positionType) */
void zx_hrxml_PositionHistory_PUT_positionType(struct zx_hrxml_PositionHistory_s* x, struct zx_str* y) { x->positionType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_CountryCode) */

int zx_hrxml_PositionLocation_NUM_CountryCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CountryCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_CountryCode) */

struct zx_elem_s* zx_hrxml_PositionLocation_GET_CountryCode(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CountryCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_CountryCode) */

struct zx_elem_s* zx_hrxml_PositionLocation_POP_CountryCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CountryCode;
  if (y)
    x->CountryCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_CountryCode) */

void zx_hrxml_PositionLocation_PUSH_CountryCode(struct zx_hrxml_PositionLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CountryCode->g;
  x->CountryCode = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_CountryCode) */

void zx_hrxml_PositionLocation_REV_CountryCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CountryCode;
  if (!y) return;
  x->CountryCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CountryCode->g;
    x->CountryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_CountryCode) */

void zx_hrxml_PositionLocation_PUT_CountryCode(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CountryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CountryCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_CountryCode) */

void zx_hrxml_PositionLocation_ADD_CountryCode(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CountryCode->g;
    x->CountryCode = z;
    return;
  case -1:
    y = x->CountryCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_CountryCode) */

void zx_hrxml_PositionLocation_DEL_CountryCode(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CountryCode = (struct zx_elem_s*)x->CountryCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CountryCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_PostalCode) */

int zx_hrxml_PositionLocation_NUM_PostalCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_PostalCode) */

struct zx_elem_s* zx_hrxml_PositionLocation_GET_PostalCode(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PostalCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_PostalCode) */

struct zx_elem_s* zx_hrxml_PositionLocation_POP_PostalCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PostalCode;
  if (y)
    x->PostalCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_PostalCode) */

void zx_hrxml_PositionLocation_PUSH_PostalCode(struct zx_hrxml_PositionLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PostalCode->g;
  x->PostalCode = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_PostalCode) */

void zx_hrxml_PositionLocation_REV_PostalCode(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PostalCode;
  if (!y) return;
  x->PostalCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PostalCode->g;
    x->PostalCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_PostalCode) */

void zx_hrxml_PositionLocation_PUT_PostalCode(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PostalCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PostalCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_PostalCode) */

void zx_hrxml_PositionLocation_ADD_PostalCode(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PostalCode->g;
    x->PostalCode = z;
    return;
  case -1:
    y = x->PostalCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_PostalCode) */

void zx_hrxml_PositionLocation_DEL_PostalCode(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalCode = (struct zx_elem_s*)x->PostalCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PostalCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_Region) */

int zx_hrxml_PositionLocation_NUM_Region(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Region; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_Region) */

struct zx_elem_s* zx_hrxml_PositionLocation_GET_Region(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Region; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_Region) */

struct zx_elem_s* zx_hrxml_PositionLocation_POP_Region(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Region;
  if (y)
    x->Region = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_Region) */

void zx_hrxml_PositionLocation_PUSH_Region(struct zx_hrxml_PositionLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Region->g;
  x->Region = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_Region) */

void zx_hrxml_PositionLocation_REV_Region(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Region;
  if (!y) return;
  x->Region = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Region->g;
    x->Region = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_Region) */

void zx_hrxml_PositionLocation_PUT_Region(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Region;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Region = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_Region) */

void zx_hrxml_PositionLocation_ADD_Region(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Region->g;
    x->Region = z;
    return;
  case -1:
    y = x->Region;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_Region) */

void zx_hrxml_PositionLocation_DEL_Region(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Region = (struct zx_elem_s*)x->Region->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Region;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_Municipality) */

int zx_hrxml_PositionLocation_NUM_Municipality(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Municipality; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_Municipality) */

struct zx_elem_s* zx_hrxml_PositionLocation_GET_Municipality(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Municipality; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_Municipality) */

struct zx_elem_s* zx_hrxml_PositionLocation_POP_Municipality(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Municipality;
  if (y)
    x->Municipality = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_Municipality) */

void zx_hrxml_PositionLocation_PUSH_Municipality(struct zx_hrxml_PositionLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Municipality->g;
  x->Municipality = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_Municipality) */

void zx_hrxml_PositionLocation_REV_Municipality(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Municipality;
  if (!y) return;
  x->Municipality = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Municipality->g;
    x->Municipality = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_Municipality) */

void zx_hrxml_PositionLocation_PUT_Municipality(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Municipality;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Municipality = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_Municipality) */

void zx_hrxml_PositionLocation_ADD_Municipality(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Municipality->g;
    x->Municipality = z;
    return;
  case -1:
    y = x->Municipality;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_Municipality) */

void zx_hrxml_PositionLocation_DEL_Municipality(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Municipality = (struct zx_elem_s*)x->Municipality->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Municipality;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_DeliveryAddress) */

int zx_hrxml_PositionLocation_NUM_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DeliveryAddress; y; ++n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_DeliveryAddress) */

struct zx_hrxml_DeliveryAddress_s* zx_hrxml_PositionLocation_GET_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return 0;
  for (y = x->DeliveryAddress; n>=0 && y; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_DeliveryAddress) */

struct zx_hrxml_DeliveryAddress_s* zx_hrxml_PositionLocation_POP_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return 0;
  y = x->DeliveryAddress;
  if (y)
    x->DeliveryAddress = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_DeliveryAddress) */

void zx_hrxml_PositionLocation_PUSH_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x, struct zx_hrxml_DeliveryAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DeliveryAddress->gg.g;
  x->DeliveryAddress = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_DeliveryAddress) */

void zx_hrxml_PositionLocation_REV_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* nxt;
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return;
  y = x->DeliveryAddress;
  if (!y) return;
  x->DeliveryAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->DeliveryAddress->gg.g;
    x->DeliveryAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_DeliveryAddress) */

void zx_hrxml_PositionLocation_PUT_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_hrxml_DeliveryAddress_s* z)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x || !z) return;
  y = x->DeliveryAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DeliveryAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_DeliveryAddress) */

void zx_hrxml_PositionLocation_ADD_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_hrxml_DeliveryAddress_s* z)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DeliveryAddress->gg.g;
    x->DeliveryAddress = z;
    return;
  case -1:
    y = x->DeliveryAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DeliveryAddress; n > 1 && y; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_DeliveryAddress) */

void zx_hrxml_PositionLocation_DEL_DeliveryAddress(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DeliveryAddress = (struct zx_hrxml_DeliveryAddress_s*)x->DeliveryAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DeliveryAddress_s*)x->DeliveryAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DeliveryAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionLocation_NUM_Recipient) */

int zx_hrxml_PositionLocation_NUM_Recipient(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_Recipient_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Recipient; y; ++n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionLocation_GET_Recipient) */

struct zx_hrxml_Recipient_s* zx_hrxml_PositionLocation_GET_Recipient(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return 0;
  for (y = x->Recipient; n>=0 && y; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_POP_Recipient) */

struct zx_hrxml_Recipient_s* zx_hrxml_PositionLocation_POP_Recipient(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return 0;
  y = x->Recipient;
  if (y)
    x->Recipient = (struct zx_hrxml_Recipient_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionLocation_PUSH_Recipient) */

void zx_hrxml_PositionLocation_PUSH_Recipient(struct zx_hrxml_PositionLocation_s* x, struct zx_hrxml_Recipient_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Recipient->gg.g;
  x->Recipient = z;
}

/* FUNC(zx_hrxml_PositionLocation_REV_Recipient) */

void zx_hrxml_PositionLocation_REV_Recipient(struct zx_hrxml_PositionLocation_s* x)
{
  struct zx_hrxml_Recipient_s* nxt;
  struct zx_hrxml_Recipient_s* y;
  if (!x) return;
  y = x->Recipient;
  if (!y) return;
  x->Recipient = 0;
  while (y) {
    nxt = (struct zx_hrxml_Recipient_s*)y->gg.g.n;
    y->gg.g.n = &x->Recipient->gg.g;
    x->Recipient = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionLocation_PUT_Recipient) */

void zx_hrxml_PositionLocation_PUT_Recipient(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_hrxml_Recipient_s* z)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x || !z) return;
  y = x->Recipient;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Recipient = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionLocation_ADD_Recipient) */

void zx_hrxml_PositionLocation_ADD_Recipient(struct zx_hrxml_PositionLocation_s* x, int n, struct zx_hrxml_Recipient_s* z)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Recipient->gg.g;
    x->Recipient = z;
    return;
  case -1:
    y = x->Recipient;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Recipient; n > 1 && y; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionLocation_DEL_Recipient) */

void zx_hrxml_PositionLocation_DEL_Recipient(struct zx_hrxml_PositionLocation_s* x, int n)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Recipient = (struct zx_hrxml_Recipient_s*)x->Recipient->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Recipient_s*)x->Recipient;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Recipient; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PositionLocation_GET_type) */
struct zx_str* zx_hrxml_PositionLocation_GET_type(struct zx_hrxml_PositionLocation_s* x) { return x->type; }
/* FUNC(zx_hrxml_PositionLocation_PUT_type) */
void zx_hrxml_PositionLocation_PUT_type(struct zx_hrxml_PositionLocation_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_Company) */

int zx_hrxml_PositionMatching_NUM_Company(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Company_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Company; y; ++n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_Company) */

struct zx_hrxml_Company_s* zx_hrxml_PositionMatching_GET_Company(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return 0;
  for (y = x->Company; n>=0 && y; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_Company) */

struct zx_hrxml_Company_s* zx_hrxml_PositionMatching_POP_Company(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return 0;
  y = x->Company;
  if (y)
    x->Company = (struct zx_hrxml_Company_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_Company) */

void zx_hrxml_PositionMatching_PUSH_Company(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_Company_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Company->gg.g;
  x->Company = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_Company) */

void zx_hrxml_PositionMatching_REV_Company(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Company_s* nxt;
  struct zx_hrxml_Company_s* y;
  if (!x) return;
  y = x->Company;
  if (!y) return;
  x->Company = 0;
  while (y) {
    nxt = (struct zx_hrxml_Company_s*)y->gg.g.n;
    y->gg.g.n = &x->Company->gg.g;
    x->Company = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_Company) */

void zx_hrxml_PositionMatching_PUT_Company(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Company_s* z)
{
  struct zx_hrxml_Company_s* y;
  if (!x || !z) return;
  y = x->Company;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Company = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_Company) */

void zx_hrxml_PositionMatching_ADD_Company(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Company_s* z)
{
  struct zx_hrxml_Company_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Company->gg.g;
    x->Company = z;
    return;
  case -1:
    y = x->Company;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Company; n > 1 && y; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_Company) */

void zx_hrxml_PositionMatching_DEL_Company(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Company = (struct zx_hrxml_Company_s*)x->Company->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Company_s*)x->Company;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Company; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_CompanyScale) */

int zx_hrxml_PositionMatching_NUM_CompanyScale(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompanyScale; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_CompanyScale) */

struct zx_elem_s* zx_hrxml_PositionMatching_GET_CompanyScale(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CompanyScale; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_CompanyScale) */

struct zx_elem_s* zx_hrxml_PositionMatching_POP_CompanyScale(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CompanyScale;
  if (y)
    x->CompanyScale = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_CompanyScale) */

void zx_hrxml_PositionMatching_PUSH_CompanyScale(struct zx_hrxml_PositionMatching_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CompanyScale->g;
  x->CompanyScale = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_CompanyScale) */

void zx_hrxml_PositionMatching_REV_CompanyScale(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CompanyScale;
  if (!y) return;
  x->CompanyScale = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CompanyScale->g;
    x->CompanyScale = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_CompanyScale) */

void zx_hrxml_PositionMatching_PUT_CompanyScale(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CompanyScale;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CompanyScale = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_CompanyScale) */

void zx_hrxml_PositionMatching_ADD_CompanyScale(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CompanyScale->g;
    x->CompanyScale = z;
    return;
  case -1:
    y = x->CompanyScale;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CompanyScale; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_CompanyScale) */

void zx_hrxml_PositionMatching_DEL_CompanyScale(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompanyScale = (struct zx_elem_s*)x->CompanyScale->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CompanyScale;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CompanyScale; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_IndustryCode) */

int zx_hrxml_PositionMatching_NUM_IndustryCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_PositionMatching_GET_IndustryCode(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_PositionMatching_POP_IndustryCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_IndustryCode) */

void zx_hrxml_PositionMatching_PUSH_IndustryCode(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_IndustryCode) */

void zx_hrxml_PositionMatching_REV_IndustryCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_IndustryCode) */

void zx_hrxml_PositionMatching_PUT_IndustryCode(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_IndustryCode) */

void zx_hrxml_PositionMatching_ADD_IndustryCode(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_IndustryCode) */

void zx_hrxml_PositionMatching_DEL_IndustryCode(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_PhysicalLocation) */

int zx_hrxml_PositionMatching_NUM_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PhysicalLocation; y; ++n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_PhysicalLocation) */

struct zx_hrxml_PhysicalLocation_s* zx_hrxml_PositionMatching_GET_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return 0;
  for (y = x->PhysicalLocation; n>=0 && y; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_PhysicalLocation) */

struct zx_hrxml_PhysicalLocation_s* zx_hrxml_PositionMatching_POP_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return 0;
  y = x->PhysicalLocation;
  if (y)
    x->PhysicalLocation = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_PhysicalLocation) */

void zx_hrxml_PositionMatching_PUSH_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_PhysicalLocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PhysicalLocation->gg.g;
  x->PhysicalLocation = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_PhysicalLocation) */

void zx_hrxml_PositionMatching_REV_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* nxt;
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return;
  y = x->PhysicalLocation;
  if (!y) return;
  x->PhysicalLocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n;
    y->gg.g.n = &x->PhysicalLocation->gg.g;
    x->PhysicalLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_PhysicalLocation) */

void zx_hrxml_PositionMatching_PUT_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PhysicalLocation_s* z)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x || !z) return;
  y = x->PhysicalLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PhysicalLocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_PhysicalLocation) */

void zx_hrxml_PositionMatching_ADD_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PhysicalLocation_s* z)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PhysicalLocation->gg.g;
    x->PhysicalLocation = z;
    return;
  case -1:
    y = x->PhysicalLocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PhysicalLocation; n > 1 && y; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_PhysicalLocation) */

void zx_hrxml_PositionMatching_DEL_PhysicalLocation(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PhysicalLocation = (struct zx_hrxml_PhysicalLocation_s*)x->PhysicalLocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PhysicalLocation_s*)x->PhysicalLocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PhysicalLocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_JobCategory) */

int zx_hrxml_PositionMatching_NUM_JobCategory(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobCategory; y; ++n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PositionMatching_GET_JobCategory(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  for (y = x->JobCategory; n>=0 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PositionMatching_POP_JobCategory(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  y = x->JobCategory;
  if (y)
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_JobCategory) */

void zx_hrxml_PositionMatching_PUSH_JobCategory(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_JobCategory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->JobCategory->gg.g;
  x->JobCategory = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_JobCategory) */

void zx_hrxml_PositionMatching_REV_JobCategory(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_JobCategory_s* nxt;
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  y = x->JobCategory;
  if (!y) return;
  x->JobCategory = 0;
  while (y) {
    nxt = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
    y->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_JobCategory) */

void zx_hrxml_PositionMatching_PUT_JobCategory(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  y = x->JobCategory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->JobCategory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_JobCategory) */

void zx_hrxml_PositionMatching_ADD_JobCategory(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = z;
    return;
  case -1:
    y = x->JobCategory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_JobCategory) */

void zx_hrxml_PositionMatching_DEL_JobCategory(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)x->JobCategory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_JobCategory_s*)x->JobCategory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_PositionTitle) */

int zx_hrxml_PositionMatching_NUM_PositionTitle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionTitle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_PositionTitle) */

struct zx_elem_s* zx_hrxml_PositionMatching_GET_PositionTitle(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PositionTitle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_PositionTitle) */

struct zx_elem_s* zx_hrxml_PositionMatching_POP_PositionTitle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PositionTitle;
  if (y)
    x->PositionTitle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_PositionTitle) */

void zx_hrxml_PositionMatching_PUSH_PositionTitle(struct zx_hrxml_PositionMatching_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PositionTitle->g;
  x->PositionTitle = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_PositionTitle) */

void zx_hrxml_PositionMatching_REV_PositionTitle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PositionTitle;
  if (!y) return;
  x->PositionTitle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PositionTitle->g;
    x->PositionTitle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_PositionTitle) */

void zx_hrxml_PositionMatching_PUT_PositionTitle(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PositionTitle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PositionTitle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_PositionTitle) */

void zx_hrxml_PositionMatching_ADD_PositionTitle(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PositionTitle->g;
    x->PositionTitle = z;
    return;
  case -1:
    y = x->PositionTitle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_PositionTitle) */

void zx_hrxml_PositionMatching_DEL_PositionTitle(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionTitle = (struct zx_elem_s*)x->PositionTitle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PositionTitle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_PositionClassification) */

int zx_hrxml_PositionMatching_NUM_PositionClassification(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionClassification; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_PositionClassification) */

struct zx_elem_s* zx_hrxml_PositionMatching_GET_PositionClassification(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PositionClassification; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_PositionClassification) */

struct zx_elem_s* zx_hrxml_PositionMatching_POP_PositionClassification(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PositionClassification;
  if (y)
    x->PositionClassification = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_PositionClassification) */

void zx_hrxml_PositionMatching_PUSH_PositionClassification(struct zx_hrxml_PositionMatching_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PositionClassification->g;
  x->PositionClassification = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_PositionClassification) */

void zx_hrxml_PositionMatching_REV_PositionClassification(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PositionClassification;
  if (!y) return;
  x->PositionClassification = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PositionClassification->g;
    x->PositionClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_PositionClassification) */

void zx_hrxml_PositionMatching_PUT_PositionClassification(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PositionClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PositionClassification = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_PositionClassification) */

void zx_hrxml_PositionMatching_ADD_PositionClassification(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PositionClassification->g;
    x->PositionClassification = z;
    return;
  case -1:
    y = x->PositionClassification;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionClassification; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_PositionClassification) */

void zx_hrxml_PositionMatching_DEL_PositionClassification(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionClassification = (struct zx_elem_s*)x->PositionClassification->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PositionClassification;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionClassification; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_PositionSchedule) */

int zx_hrxml_PositionMatching_NUM_PositionSchedule(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PositionSchedule_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionSchedule; y; ++n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_PositionSchedule) */

struct zx_hrxml_PositionSchedule_s* zx_hrxml_PositionMatching_GET_PositionSchedule(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return 0;
  for (y = x->PositionSchedule; n>=0 && y; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_PositionSchedule) */

struct zx_hrxml_PositionSchedule_s* zx_hrxml_PositionMatching_POP_PositionSchedule(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return 0;
  y = x->PositionSchedule;
  if (y)
    x->PositionSchedule = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_PositionSchedule) */

void zx_hrxml_PositionMatching_PUSH_PositionSchedule(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_PositionSchedule_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PositionSchedule->gg.g;
  x->PositionSchedule = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_PositionSchedule) */

void zx_hrxml_PositionMatching_REV_PositionSchedule(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PositionSchedule_s* nxt;
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return;
  y = x->PositionSchedule;
  if (!y) return;
  x->PositionSchedule = 0;
  while (y) {
    nxt = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n;
    y->gg.g.n = &x->PositionSchedule->gg.g;
    x->PositionSchedule = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_PositionSchedule) */

void zx_hrxml_PositionMatching_PUT_PositionSchedule(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PositionSchedule_s* z)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x || !z) return;
  y = x->PositionSchedule;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PositionSchedule = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_PositionSchedule) */

void zx_hrxml_PositionMatching_ADD_PositionSchedule(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PositionSchedule_s* z)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PositionSchedule->gg.g;
    x->PositionSchedule = z;
    return;
  case -1:
    y = x->PositionSchedule;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionSchedule; n > 1 && y; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_PositionSchedule) */

void zx_hrxml_PositionMatching_DEL_PositionSchedule(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionSchedule = (struct zx_hrxml_PositionSchedule_s*)x->PositionSchedule->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PositionSchedule_s*)x->PositionSchedule;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionSchedule; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_Shift) */

int zx_hrxml_PositionMatching_NUM_Shift(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Shift_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Shift; y; ++n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_Shift) */

struct zx_hrxml_Shift_s* zx_hrxml_PositionMatching_GET_Shift(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return 0;
  for (y = x->Shift; n>=0 && y; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_Shift) */

struct zx_hrxml_Shift_s* zx_hrxml_PositionMatching_POP_Shift(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return 0;
  y = x->Shift;
  if (y)
    x->Shift = (struct zx_hrxml_Shift_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_Shift) */

void zx_hrxml_PositionMatching_PUSH_Shift(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_Shift_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Shift->gg.g;
  x->Shift = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_Shift) */

void zx_hrxml_PositionMatching_REV_Shift(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Shift_s* nxt;
  struct zx_hrxml_Shift_s* y;
  if (!x) return;
  y = x->Shift;
  if (!y) return;
  x->Shift = 0;
  while (y) {
    nxt = (struct zx_hrxml_Shift_s*)y->gg.g.n;
    y->gg.g.n = &x->Shift->gg.g;
    x->Shift = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_Shift) */

void zx_hrxml_PositionMatching_PUT_Shift(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Shift_s* z)
{
  struct zx_hrxml_Shift_s* y;
  if (!x || !z) return;
  y = x->Shift;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Shift = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_Shift) */

void zx_hrxml_PositionMatching_ADD_Shift(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Shift_s* z)
{
  struct zx_hrxml_Shift_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Shift->gg.g;
    x->Shift = z;
    return;
  case -1:
    y = x->Shift;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Shift; n > 1 && y; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_Shift) */

void zx_hrxml_PositionMatching_DEL_Shift(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Shift = (struct zx_hrxml_Shift_s*)x->Shift->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Shift_s*)x->Shift;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Shift; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_Competency) */

int zx_hrxml_PositionMatching_NUM_Competency(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Competency_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Competency; y; ++n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PositionMatching_GET_Competency(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  for (y = x->Competency; n>=0 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PositionMatching_POP_Competency(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  y = x->Competency;
  if (y)
    x->Competency = (struct zx_hrxml_Competency_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_Competency) */

void zx_hrxml_PositionMatching_PUSH_Competency(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_Competency_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Competency->gg.g;
  x->Competency = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_Competency) */

void zx_hrxml_PositionMatching_REV_Competency(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Competency_s* nxt;
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  y = x->Competency;
  if (!y) return;
  x->Competency = 0;
  while (y) {
    nxt = (struct zx_hrxml_Competency_s*)y->gg.g.n;
    y->gg.g.n = &x->Competency->gg.g;
    x->Competency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_Competency) */

void zx_hrxml_PositionMatching_PUT_Competency(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  y = x->Competency;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Competency = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_Competency) */

void zx_hrxml_PositionMatching_ADD_Competency(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Competency->gg.g;
    x->Competency = z;
    return;
  case -1:
    y = x->Competency;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_Competency) */

void zx_hrxml_PositionMatching_DEL_Competency(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Competency = (struct zx_hrxml_Competency_s*)x->Competency->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Competency_s*)x->Competency;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_RemunerationPackage) */

int zx_hrxml_PositionMatching_NUM_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RemunerationPackage; y; ++n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_RemunerationPackage) */

struct zx_hrxml_RemunerationPackage_s* zx_hrxml_PositionMatching_GET_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return 0;
  for (y = x->RemunerationPackage; n>=0 && y; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_RemunerationPackage) */

struct zx_hrxml_RemunerationPackage_s* zx_hrxml_PositionMatching_POP_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return 0;
  y = x->RemunerationPackage;
  if (y)
    x->RemunerationPackage = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_RemunerationPackage) */

void zx_hrxml_PositionMatching_PUSH_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_RemunerationPackage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RemunerationPackage->gg.g;
  x->RemunerationPackage = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_RemunerationPackage) */

void zx_hrxml_PositionMatching_REV_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* nxt;
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return;
  y = x->RemunerationPackage;
  if (!y) return;
  x->RemunerationPackage = 0;
  while (y) {
    nxt = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n;
    y->gg.g.n = &x->RemunerationPackage->gg.g;
    x->RemunerationPackage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_RemunerationPackage) */

void zx_hrxml_PositionMatching_PUT_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_RemunerationPackage_s* z)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x || !z) return;
  y = x->RemunerationPackage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RemunerationPackage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_RemunerationPackage) */

void zx_hrxml_PositionMatching_ADD_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_RemunerationPackage_s* z)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RemunerationPackage->gg.g;
    x->RemunerationPackage = z;
    return;
  case -1:
    y = x->RemunerationPackage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RemunerationPackage; n > 1 && y; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_RemunerationPackage) */

void zx_hrxml_PositionMatching_DEL_RemunerationPackage(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RemunerationPackage = (struct zx_hrxml_RemunerationPackage_s*)x->RemunerationPackage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RemunerationPackage_s*)x->RemunerationPackage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RemunerationPackage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_WorkStyle) */

int zx_hrxml_PositionMatching_NUM_WorkStyle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkStyle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_WorkStyle) */

struct zx_elem_s* zx_hrxml_PositionMatching_GET_WorkStyle(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->WorkStyle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_WorkStyle) */

struct zx_elem_s* zx_hrxml_PositionMatching_POP_WorkStyle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->WorkStyle;
  if (y)
    x->WorkStyle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_WorkStyle) */

void zx_hrxml_PositionMatching_PUSH_WorkStyle(struct zx_hrxml_PositionMatching_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->WorkStyle->g;
  x->WorkStyle = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_WorkStyle) */

void zx_hrxml_PositionMatching_REV_WorkStyle(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->WorkStyle;
  if (!y) return;
  x->WorkStyle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->WorkStyle->g;
    x->WorkStyle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_WorkStyle) */

void zx_hrxml_PositionMatching_PUT_WorkStyle(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->WorkStyle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->WorkStyle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_WorkStyle) */

void zx_hrxml_PositionMatching_ADD_WorkStyle(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->WorkStyle->g;
    x->WorkStyle = z;
    return;
  case -1:
    y = x->WorkStyle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkStyle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_WorkStyle) */

void zx_hrxml_PositionMatching_DEL_WorkStyle(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkStyle = (struct zx_elem_s*)x->WorkStyle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->WorkStyle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkStyle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_DressCode) */

int zx_hrxml_PositionMatching_NUM_DressCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DressCode; y; ++n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_PositionMatching_GET_DressCode(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  for (y = x->DressCode; n>=0 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_PositionMatching_POP_DressCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  y = x->DressCode;
  if (y)
    x->DressCode = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_DressCode) */

void zx_hrxml_PositionMatching_PUSH_DressCode(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_DressCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DressCode->gg.g;
  x->DressCode = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_DressCode) */

void zx_hrxml_PositionMatching_REV_DressCode(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_DressCode_s* nxt;
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  y = x->DressCode;
  if (!y) return;
  x->DressCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
    y->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_DressCode) */

void zx_hrxml_PositionMatching_PUT_DressCode(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  y = x->DressCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DressCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_DressCode) */

void zx_hrxml_PositionMatching_ADD_DressCode(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = z;
    return;
  case -1:
    y = x->DressCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_DressCode) */

void zx_hrxml_PositionMatching_DEL_DressCode(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DressCode = (struct zx_hrxml_DressCode_s*)x->DressCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DressCode_s*)x->DressCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_Travel) */

int zx_hrxml_PositionMatching_NUM_Travel(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Travel_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Travel; y; ++n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_Travel) */

struct zx_hrxml_Travel_s* zx_hrxml_PositionMatching_GET_Travel(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return 0;
  for (y = x->Travel; n>=0 && y; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_Travel) */

struct zx_hrxml_Travel_s* zx_hrxml_PositionMatching_POP_Travel(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return 0;
  y = x->Travel;
  if (y)
    x->Travel = (struct zx_hrxml_Travel_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_Travel) */

void zx_hrxml_PositionMatching_PUSH_Travel(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_Travel_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Travel->gg.g;
  x->Travel = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_Travel) */

void zx_hrxml_PositionMatching_REV_Travel(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Travel_s* nxt;
  struct zx_hrxml_Travel_s* y;
  if (!x) return;
  y = x->Travel;
  if (!y) return;
  x->Travel = 0;
  while (y) {
    nxt = (struct zx_hrxml_Travel_s*)y->gg.g.n;
    y->gg.g.n = &x->Travel->gg.g;
    x->Travel = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_Travel) */

void zx_hrxml_PositionMatching_PUT_Travel(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Travel_s* z)
{
  struct zx_hrxml_Travel_s* y;
  if (!x || !z) return;
  y = x->Travel;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Travel = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_Travel) */

void zx_hrxml_PositionMatching_ADD_Travel(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Travel_s* z)
{
  struct zx_hrxml_Travel_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Travel->gg.g;
    x->Travel = z;
    return;
  case -1:
    y = x->Travel;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Travel; n > 1 && y; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_Travel) */

void zx_hrxml_PositionMatching_DEL_Travel(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Travel = (struct zx_hrxml_Travel_s*)x->Travel->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Travel_s*)x->Travel;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Travel; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_Relocation) */

int zx_hrxml_PositionMatching_NUM_Relocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Relocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Relocation; y; ++n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_Relocation) */

struct zx_hrxml_Relocation_s* zx_hrxml_PositionMatching_GET_Relocation(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return 0;
  for (y = x->Relocation; n>=0 && y; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_Relocation) */

struct zx_hrxml_Relocation_s* zx_hrxml_PositionMatching_POP_Relocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return 0;
  y = x->Relocation;
  if (y)
    x->Relocation = (struct zx_hrxml_Relocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_Relocation) */

void zx_hrxml_PositionMatching_PUSH_Relocation(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_Relocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Relocation->gg.g;
  x->Relocation = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_Relocation) */

void zx_hrxml_PositionMatching_REV_Relocation(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_Relocation_s* nxt;
  struct zx_hrxml_Relocation_s* y;
  if (!x) return;
  y = x->Relocation;
  if (!y) return;
  x->Relocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_Relocation_s*)y->gg.g.n;
    y->gg.g.n = &x->Relocation->gg.g;
    x->Relocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_Relocation) */

void zx_hrxml_PositionMatching_PUT_Relocation(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Relocation_s* z)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x || !z) return;
  y = x->Relocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Relocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_Relocation) */

void zx_hrxml_PositionMatching_ADD_Relocation(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_Relocation_s* z)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Relocation->gg.g;
    x->Relocation = z;
    return;
  case -1:
    y = x->Relocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Relocation; n > 1 && y; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_Relocation) */

void zx_hrxml_PositionMatching_DEL_Relocation(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Relocation = (struct zx_hrxml_Relocation_s*)x->Relocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Relocation_s*)x->Relocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Relocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_PreferredLanguage) */

int zx_hrxml_PositionMatching_NUM_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredLanguage; y; ++n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_PreferredLanguage) */

struct zx_hrxml_PreferredLanguage_s* zx_hrxml_PositionMatching_GET_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return 0;
  for (y = x->PreferredLanguage; n>=0 && y; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_PreferredLanguage) */

struct zx_hrxml_PreferredLanguage_s* zx_hrxml_PositionMatching_POP_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return 0;
  y = x->PreferredLanguage;
  if (y)
    x->PreferredLanguage = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_PreferredLanguage) */

void zx_hrxml_PositionMatching_PUSH_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_PreferredLanguage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PreferredLanguage->gg.g;
  x->PreferredLanguage = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_PreferredLanguage) */

void zx_hrxml_PositionMatching_REV_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* nxt;
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return;
  y = x->PreferredLanguage;
  if (!y) return;
  x->PreferredLanguage = 0;
  while (y) {
    nxt = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n;
    y->gg.g.n = &x->PreferredLanguage->gg.g;
    x->PreferredLanguage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_PreferredLanguage) */

void zx_hrxml_PositionMatching_PUT_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PreferredLanguage_s* z)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x || !z) return;
  y = x->PreferredLanguage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PreferredLanguage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_PreferredLanguage) */

void zx_hrxml_PositionMatching_ADD_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_PreferredLanguage_s* z)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PreferredLanguage->gg.g;
    x->PreferredLanguage = z;
    return;
  case -1:
    y = x->PreferredLanguage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredLanguage; n > 1 && y; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_PreferredLanguage) */

void zx_hrxml_PositionMatching_DEL_PreferredLanguage(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredLanguage = (struct zx_hrxml_PreferredLanguage_s*)x->PreferredLanguage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PreferredLanguage_s*)x->PreferredLanguage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredLanguage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionMatching_NUM_UserArea) */

int zx_hrxml_PositionMatching_NUM_UserArea(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionMatching_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PositionMatching_GET_UserArea(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PositionMatching_POP_UserArea(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionMatching_PUSH_UserArea) */

void zx_hrxml_PositionMatching_PUSH_UserArea(struct zx_hrxml_PositionMatching_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PositionMatching_REV_UserArea) */

void zx_hrxml_PositionMatching_REV_UserArea(struct zx_hrxml_PositionMatching_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionMatching_PUT_UserArea) */

void zx_hrxml_PositionMatching_PUT_UserArea(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionMatching_ADD_UserArea) */

void zx_hrxml_PositionMatching_ADD_UserArea(struct zx_hrxml_PositionMatching_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionMatching_DEL_UserArea) */

void zx_hrxml_PositionMatching_DEL_UserArea(struct zx_hrxml_PositionMatching_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionPosting_NUM_Id) */

int zx_hrxml_PositionPosting_NUM_Id(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionPosting_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PositionPosting_GET_Id(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_PositionPosting_POP_Id(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_PUSH_Id) */

void zx_hrxml_PositionPosting_PUSH_Id(struct zx_hrxml_PositionPosting_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_PositionPosting_REV_Id) */

void zx_hrxml_PositionPosting_REV_Id(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionPosting_PUT_Id) */

void zx_hrxml_PositionPosting_PUT_Id(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionPosting_ADD_Id) */

void zx_hrxml_PositionPosting_ADD_Id(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionPosting_DEL_Id) */

void zx_hrxml_PositionPosting_DEL_Id(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionPosting_NUM_Title) */

int zx_hrxml_PositionPosting_NUM_Title(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionPosting_GET_Title) */

struct zx_elem_s* zx_hrxml_PositionPosting_GET_Title(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_POP_Title) */

struct zx_elem_s* zx_hrxml_PositionPosting_POP_Title(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_PUSH_Title) */

void zx_hrxml_PositionPosting_PUSH_Title(struct zx_hrxml_PositionPosting_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_PositionPosting_REV_Title) */

void zx_hrxml_PositionPosting_REV_Title(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionPosting_PUT_Title) */

void zx_hrxml_PositionPosting_PUT_Title(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionPosting_ADD_Title) */

void zx_hrxml_PositionPosting_ADD_Title(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionPosting_DEL_Title) */

void zx_hrxml_PositionPosting_DEL_Title(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionPosting_NUM_Link) */

int zx_hrxml_PositionPosting_NUM_Link(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionPosting_GET_Link) */

struct zx_elem_s* zx_hrxml_PositionPosting_GET_Link(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_POP_Link) */

struct zx_elem_s* zx_hrxml_PositionPosting_POP_Link(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_PUSH_Link) */

void zx_hrxml_PositionPosting_PUSH_Link(struct zx_hrxml_PositionPosting_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_PositionPosting_REV_Link) */

void zx_hrxml_PositionPosting_REV_Link(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionPosting_PUT_Link) */

void zx_hrxml_PositionPosting_PUT_Link(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PositionPosting_ADD_Link) */

void zx_hrxml_PositionPosting_ADD_Link(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PositionPosting_DEL_Link) */

void zx_hrxml_PositionPosting_DEL_Link(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionPosting_NUM_SearchCriteria) */

int zx_hrxml_PositionPosting_NUM_SearchCriteria(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchCriteria_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchCriteria; y; ++n, y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionPosting_GET_SearchCriteria) */

struct zx_hrxml_SearchCriteria_s* zx_hrxml_PositionPosting_GET_SearchCriteria(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x) return 0;
  for (y = x->SearchCriteria; n>=0 && y; --n, y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_POP_SearchCriteria) */

struct zx_hrxml_SearchCriteria_s* zx_hrxml_PositionPosting_POP_SearchCriteria(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x) return 0;
  y = x->SearchCriteria;
  if (y)
    x->SearchCriteria = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_PUSH_SearchCriteria) */

void zx_hrxml_PositionPosting_PUSH_SearchCriteria(struct zx_hrxml_PositionPosting_s* x, struct zx_hrxml_SearchCriteria_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchCriteria->gg.g;
  x->SearchCriteria = z;
}

/* FUNC(zx_hrxml_PositionPosting_REV_SearchCriteria) */

void zx_hrxml_PositionPosting_REV_SearchCriteria(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchCriteria_s* nxt;
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x) return;
  y = x->SearchCriteria;
  if (!y) return;
  x->SearchCriteria = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchCriteria->gg.g;
    x->SearchCriteria = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionPosting_PUT_SearchCriteria) */

void zx_hrxml_PositionPosting_PUT_SearchCriteria(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_SearchCriteria_s* z)
{
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x || !z) return;
  y = x->SearchCriteria;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchCriteria = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionPosting_ADD_SearchCriteria) */

void zx_hrxml_PositionPosting_ADD_SearchCriteria(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_SearchCriteria_s* z)
{
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchCriteria->gg.g;
    x->SearchCriteria = z;
    return;
  case -1:
    y = x->SearchCriteria;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriteria; n > 1 && y; --n, y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionPosting_DEL_SearchCriteria) */

void zx_hrxml_PositionPosting_DEL_SearchCriteria(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_SearchCriteria_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchCriteria = (struct zx_hrxml_SearchCriteria_s*)x->SearchCriteria->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchCriteria_s*)x->SearchCriteria;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriteria; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriteria_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PositionPosting_NUM_SearchResult) */

int zx_hrxml_PositionPosting_NUM_SearchResult(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchResult_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchResult; y; ++n, y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PositionPosting_GET_SearchResult) */

struct zx_hrxml_SearchResult_s* zx_hrxml_PositionPosting_GET_SearchResult(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_SearchResult_s* y;
  if (!x) return 0;
  for (y = x->SearchResult; n>=0 && y; --n, y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_POP_SearchResult) */

struct zx_hrxml_SearchResult_s* zx_hrxml_PositionPosting_POP_SearchResult(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchResult_s* y;
  if (!x) return 0;
  y = x->SearchResult;
  if (y)
    x->SearchResult = (struct zx_hrxml_SearchResult_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PositionPosting_PUSH_SearchResult) */

void zx_hrxml_PositionPosting_PUSH_SearchResult(struct zx_hrxml_PositionPosting_s* x, struct zx_hrxml_SearchResult_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchResult->gg.g;
  x->SearchResult = z;
}

/* FUNC(zx_hrxml_PositionPosting_REV_SearchResult) */

void zx_hrxml_PositionPosting_REV_SearchResult(struct zx_hrxml_PositionPosting_s* x)
{
  struct zx_hrxml_SearchResult_s* nxt;
  struct zx_hrxml_SearchResult_s* y;
  if (!x) return;
  y = x->SearchResult;
  if (!y) return;
  x->SearchResult = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchResult_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchResult->gg.g;
    x->SearchResult = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PositionPosting_PUT_SearchResult) */

void zx_hrxml_PositionPosting_PUT_SearchResult(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_SearchResult_s* z)
{
  struct zx_hrxml_SearchResult_s* y;
  if (!x || !z) return;
  y = x->SearchResult;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchResult = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PositionPosting_ADD_SearchResult) */

void zx_hrxml_PositionPosting_ADD_SearchResult(struct zx_hrxml_PositionPosting_s* x, int n, struct zx_hrxml_SearchResult_s* z)
{
  struct zx_hrxml_SearchResult_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchResult->gg.g;
    x->SearchResult = z;
    return;
  case -1:
    y = x->SearchResult;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchResult; n > 1 && y; --n, y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PositionPosting_DEL_SearchResult) */

void zx_hrxml_PositionPosting_DEL_SearchResult(struct zx_hrxml_PositionPosting_s* x, int n)
{
  struct zx_hrxml_SearchResult_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchResult = (struct zx_hrxml_SearchResult_s*)x->SearchResult->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchResult_s*)x->SearchResult;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchResult; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_PositionSchedule_GET_percentage) */
struct zx_str* zx_hrxml_PositionSchedule_GET_percentage(struct zx_hrxml_PositionSchedule_s* x) { return x->percentage; }
/* FUNC(zx_hrxml_PositionSchedule_PUT_percentage) */
void zx_hrxml_PositionSchedule_PUT_percentage(struct zx_hrxml_PositionSchedule_s* x, struct zx_str* y) { x->percentage = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_CountryCode) */

int zx_hrxml_PostalAddress_NUM_CountryCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CountryCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_CountryCode) */

struct zx_elem_s* zx_hrxml_PostalAddress_GET_CountryCode(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CountryCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_CountryCode) */

struct zx_elem_s* zx_hrxml_PostalAddress_POP_CountryCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CountryCode;
  if (y)
    x->CountryCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_CountryCode) */

void zx_hrxml_PostalAddress_PUSH_CountryCode(struct zx_hrxml_PostalAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CountryCode->g;
  x->CountryCode = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_CountryCode) */

void zx_hrxml_PostalAddress_REV_CountryCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CountryCode;
  if (!y) return;
  x->CountryCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CountryCode->g;
    x->CountryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_CountryCode) */

void zx_hrxml_PostalAddress_PUT_CountryCode(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CountryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CountryCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_CountryCode) */

void zx_hrxml_PostalAddress_ADD_CountryCode(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CountryCode->g;
    x->CountryCode = z;
    return;
  case -1:
    y = x->CountryCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_CountryCode) */

void zx_hrxml_PostalAddress_DEL_CountryCode(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CountryCode = (struct zx_elem_s*)x->CountryCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CountryCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CountryCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_PostalCode) */

int zx_hrxml_PostalAddress_NUM_PostalCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalCode; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_PostalCode) */

struct zx_elem_s* zx_hrxml_PostalAddress_GET_PostalCode(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PostalCode; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_PostalCode) */

struct zx_elem_s* zx_hrxml_PostalAddress_POP_PostalCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PostalCode;
  if (y)
    x->PostalCode = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_PostalCode) */

void zx_hrxml_PostalAddress_PUSH_PostalCode(struct zx_hrxml_PostalAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PostalCode->g;
  x->PostalCode = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_PostalCode) */

void zx_hrxml_PostalAddress_REV_PostalCode(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PostalCode;
  if (!y) return;
  x->PostalCode = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PostalCode->g;
    x->PostalCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_PostalCode) */

void zx_hrxml_PostalAddress_PUT_PostalCode(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PostalCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PostalCode = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_PostalCode) */

void zx_hrxml_PostalAddress_ADD_PostalCode(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PostalCode->g;
    x->PostalCode = z;
    return;
  case -1:
    y = x->PostalCode;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_PostalCode) */

void zx_hrxml_PostalAddress_DEL_PostalCode(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalCode = (struct zx_elem_s*)x->PostalCode->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PostalCode;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PostalCode; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_Region) */

int zx_hrxml_PostalAddress_NUM_Region(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Region; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_Region) */

struct zx_elem_s* zx_hrxml_PostalAddress_GET_Region(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Region; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_Region) */

struct zx_elem_s* zx_hrxml_PostalAddress_POP_Region(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Region;
  if (y)
    x->Region = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_Region) */

void zx_hrxml_PostalAddress_PUSH_Region(struct zx_hrxml_PostalAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Region->g;
  x->Region = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_Region) */

void zx_hrxml_PostalAddress_REV_Region(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Region;
  if (!y) return;
  x->Region = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Region->g;
    x->Region = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_Region) */

void zx_hrxml_PostalAddress_PUT_Region(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Region;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Region = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_Region) */

void zx_hrxml_PostalAddress_ADD_Region(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Region->g;
    x->Region = z;
    return;
  case -1:
    y = x->Region;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_Region) */

void zx_hrxml_PostalAddress_DEL_Region(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Region = (struct zx_elem_s*)x->Region->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Region;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Region; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_Municipality) */

int zx_hrxml_PostalAddress_NUM_Municipality(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Municipality; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_Municipality) */

struct zx_elem_s* zx_hrxml_PostalAddress_GET_Municipality(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Municipality; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_Municipality) */

struct zx_elem_s* zx_hrxml_PostalAddress_POP_Municipality(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Municipality;
  if (y)
    x->Municipality = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_Municipality) */

void zx_hrxml_PostalAddress_PUSH_Municipality(struct zx_hrxml_PostalAddress_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Municipality->g;
  x->Municipality = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_Municipality) */

void zx_hrxml_PostalAddress_REV_Municipality(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Municipality;
  if (!y) return;
  x->Municipality = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Municipality->g;
    x->Municipality = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_Municipality) */

void zx_hrxml_PostalAddress_PUT_Municipality(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Municipality;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Municipality = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_Municipality) */

void zx_hrxml_PostalAddress_ADD_Municipality(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Municipality->g;
    x->Municipality = z;
    return;
  case -1:
    y = x->Municipality;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_Municipality) */

void zx_hrxml_PostalAddress_DEL_Municipality(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Municipality = (struct zx_elem_s*)x->Municipality->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Municipality;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Municipality; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_DeliveryAddress) */

int zx_hrxml_PostalAddress_NUM_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DeliveryAddress; y; ++n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_DeliveryAddress) */

struct zx_hrxml_DeliveryAddress_s* zx_hrxml_PostalAddress_GET_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return 0;
  for (y = x->DeliveryAddress; n>=0 && y; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_DeliveryAddress) */

struct zx_hrxml_DeliveryAddress_s* zx_hrxml_PostalAddress_POP_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return 0;
  y = x->DeliveryAddress;
  if (y)
    x->DeliveryAddress = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_DeliveryAddress) */

void zx_hrxml_PostalAddress_PUSH_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x, struct zx_hrxml_DeliveryAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DeliveryAddress->gg.g;
  x->DeliveryAddress = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_DeliveryAddress) */

void zx_hrxml_PostalAddress_REV_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_DeliveryAddress_s* nxt;
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return;
  y = x->DeliveryAddress;
  if (!y) return;
  x->DeliveryAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->DeliveryAddress->gg.g;
    x->DeliveryAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_DeliveryAddress) */

void zx_hrxml_PostalAddress_PUT_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_hrxml_DeliveryAddress_s* z)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x || !z) return;
  y = x->DeliveryAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DeliveryAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_DeliveryAddress) */

void zx_hrxml_PostalAddress_ADD_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_hrxml_DeliveryAddress_s* z)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DeliveryAddress->gg.g;
    x->DeliveryAddress = z;
    return;
  case -1:
    y = x->DeliveryAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DeliveryAddress; n > 1 && y; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_DeliveryAddress) */

void zx_hrxml_PostalAddress_DEL_DeliveryAddress(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_hrxml_DeliveryAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DeliveryAddress = (struct zx_hrxml_DeliveryAddress_s*)x->DeliveryAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DeliveryAddress_s*)x->DeliveryAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DeliveryAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DeliveryAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PostalAddress_NUM_Recipient) */

int zx_hrxml_PostalAddress_NUM_Recipient(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_Recipient_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Recipient; y; ++n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PostalAddress_GET_Recipient) */

struct zx_hrxml_Recipient_s* zx_hrxml_PostalAddress_GET_Recipient(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return 0;
  for (y = x->Recipient; n>=0 && y; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_POP_Recipient) */

struct zx_hrxml_Recipient_s* zx_hrxml_PostalAddress_POP_Recipient(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return 0;
  y = x->Recipient;
  if (y)
    x->Recipient = (struct zx_hrxml_Recipient_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PostalAddress_PUSH_Recipient) */

void zx_hrxml_PostalAddress_PUSH_Recipient(struct zx_hrxml_PostalAddress_s* x, struct zx_hrxml_Recipient_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Recipient->gg.g;
  x->Recipient = z;
}

/* FUNC(zx_hrxml_PostalAddress_REV_Recipient) */

void zx_hrxml_PostalAddress_REV_Recipient(struct zx_hrxml_PostalAddress_s* x)
{
  struct zx_hrxml_Recipient_s* nxt;
  struct zx_hrxml_Recipient_s* y;
  if (!x) return;
  y = x->Recipient;
  if (!y) return;
  x->Recipient = 0;
  while (y) {
    nxt = (struct zx_hrxml_Recipient_s*)y->gg.g.n;
    y->gg.g.n = &x->Recipient->gg.g;
    x->Recipient = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PostalAddress_PUT_Recipient) */

void zx_hrxml_PostalAddress_PUT_Recipient(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_hrxml_Recipient_s* z)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x || !z) return;
  y = x->Recipient;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Recipient = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PostalAddress_ADD_Recipient) */

void zx_hrxml_PostalAddress_ADD_Recipient(struct zx_hrxml_PostalAddress_s* x, int n, struct zx_hrxml_Recipient_s* z)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Recipient->gg.g;
    x->Recipient = z;
    return;
  case -1:
    y = x->Recipient;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Recipient; n > 1 && y; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PostalAddress_DEL_Recipient) */

void zx_hrxml_PostalAddress_DEL_Recipient(struct zx_hrxml_PostalAddress_s* x, int n)
{
  struct zx_hrxml_Recipient_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Recipient = (struct zx_hrxml_Recipient_s*)x->Recipient->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Recipient_s*)x->Recipient;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Recipient; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Recipient_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_PostalAddress_GET_type) */
struct zx_str* zx_hrxml_PostalAddress_GET_type(struct zx_hrxml_PostalAddress_s* x) { return x->type; }
/* FUNC(zx_hrxml_PostalAddress_PUT_type) */
void zx_hrxml_PostalAddress_PUT_type(struct zx_hrxml_PostalAddress_s* x, struct zx_str* y) { x->type = y; }












#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Company) */

int zx_hrxml_PreferredPosition_NUM_Company(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Company_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Company; y; ++n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Company) */

struct zx_hrxml_Company_s* zx_hrxml_PreferredPosition_GET_Company(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return 0;
  for (y = x->Company; n>=0 && y; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Company) */

struct zx_hrxml_Company_s* zx_hrxml_PreferredPosition_POP_Company(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return 0;
  y = x->Company;
  if (y)
    x->Company = (struct zx_hrxml_Company_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Company) */

void zx_hrxml_PreferredPosition_PUSH_Company(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Company_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Company->gg.g;
  x->Company = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Company) */

void zx_hrxml_PreferredPosition_REV_Company(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Company_s* nxt;
  struct zx_hrxml_Company_s* y;
  if (!x) return;
  y = x->Company;
  if (!y) return;
  x->Company = 0;
  while (y) {
    nxt = (struct zx_hrxml_Company_s*)y->gg.g.n;
    y->gg.g.n = &x->Company->gg.g;
    x->Company = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Company) */

void zx_hrxml_PreferredPosition_PUT_Company(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Company_s* z)
{
  struct zx_hrxml_Company_s* y;
  if (!x || !z) return;
  y = x->Company;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Company = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Company) */

void zx_hrxml_PreferredPosition_ADD_Company(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Company_s* z)
{
  struct zx_hrxml_Company_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Company->gg.g;
    x->Company = z;
    return;
  case -1:
    y = x->Company;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Company; n > 1 && y; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Company) */

void zx_hrxml_PreferredPosition_DEL_Company(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Company_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Company = (struct zx_hrxml_Company_s*)x->Company->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Company_s*)x->Company;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Company; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Company_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_CompanyScale) */

int zx_hrxml_PreferredPosition_NUM_CompanyScale(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompanyScale; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_CompanyScale) */

struct zx_elem_s* zx_hrxml_PreferredPosition_GET_CompanyScale(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CompanyScale; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_CompanyScale) */

struct zx_elem_s* zx_hrxml_PreferredPosition_POP_CompanyScale(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CompanyScale;
  if (y)
    x->CompanyScale = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_CompanyScale) */

void zx_hrxml_PreferredPosition_PUSH_CompanyScale(struct zx_hrxml_PreferredPosition_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CompanyScale->g;
  x->CompanyScale = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_CompanyScale) */

void zx_hrxml_PreferredPosition_REV_CompanyScale(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CompanyScale;
  if (!y) return;
  x->CompanyScale = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CompanyScale->g;
    x->CompanyScale = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_CompanyScale) */

void zx_hrxml_PreferredPosition_PUT_CompanyScale(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CompanyScale;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CompanyScale = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_CompanyScale) */

void zx_hrxml_PreferredPosition_ADD_CompanyScale(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CompanyScale->g;
    x->CompanyScale = z;
    return;
  case -1:
    y = x->CompanyScale;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CompanyScale; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_CompanyScale) */

void zx_hrxml_PreferredPosition_DEL_CompanyScale(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompanyScale = (struct zx_elem_s*)x->CompanyScale->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CompanyScale;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CompanyScale; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_IndustryCode) */

int zx_hrxml_PreferredPosition_NUM_IndustryCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_PreferredPosition_GET_IndustryCode(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_PreferredPosition_POP_IndustryCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_IndustryCode) */

void zx_hrxml_PreferredPosition_PUSH_IndustryCode(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_IndustryCode) */

void zx_hrxml_PreferredPosition_REV_IndustryCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_IndustryCode) */

void zx_hrxml_PreferredPosition_PUT_IndustryCode(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_IndustryCode) */

void zx_hrxml_PreferredPosition_ADD_IndustryCode(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_IndustryCode) */

void zx_hrxml_PreferredPosition_DEL_IndustryCode(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_PhysicalLocation) */

int zx_hrxml_PreferredPosition_NUM_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PhysicalLocation; y; ++n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_PhysicalLocation) */

struct zx_hrxml_PhysicalLocation_s* zx_hrxml_PreferredPosition_GET_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return 0;
  for (y = x->PhysicalLocation; n>=0 && y; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_PhysicalLocation) */

struct zx_hrxml_PhysicalLocation_s* zx_hrxml_PreferredPosition_POP_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return 0;
  y = x->PhysicalLocation;
  if (y)
    x->PhysicalLocation = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_PhysicalLocation) */

void zx_hrxml_PreferredPosition_PUSH_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_PhysicalLocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PhysicalLocation->gg.g;
  x->PhysicalLocation = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_PhysicalLocation) */

void zx_hrxml_PreferredPosition_REV_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PhysicalLocation_s* nxt;
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return;
  y = x->PhysicalLocation;
  if (!y) return;
  x->PhysicalLocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n;
    y->gg.g.n = &x->PhysicalLocation->gg.g;
    x->PhysicalLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_PhysicalLocation) */

void zx_hrxml_PreferredPosition_PUT_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PhysicalLocation_s* z)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x || !z) return;
  y = x->PhysicalLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PhysicalLocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_PhysicalLocation) */

void zx_hrxml_PreferredPosition_ADD_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PhysicalLocation_s* z)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PhysicalLocation->gg.g;
    x->PhysicalLocation = z;
    return;
  case -1:
    y = x->PhysicalLocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PhysicalLocation; n > 1 && y; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_PhysicalLocation) */

void zx_hrxml_PreferredPosition_DEL_PhysicalLocation(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PhysicalLocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PhysicalLocation = (struct zx_hrxml_PhysicalLocation_s*)x->PhysicalLocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PhysicalLocation_s*)x->PhysicalLocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PhysicalLocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PhysicalLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_JobCategory) */

int zx_hrxml_PreferredPosition_NUM_JobCategory(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->JobCategory; y; ++n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PreferredPosition_GET_JobCategory(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  for (y = x->JobCategory; n>=0 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_JobCategory) */

struct zx_hrxml_JobCategory_s* zx_hrxml_PreferredPosition_POP_JobCategory(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return 0;
  y = x->JobCategory;
  if (y)
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_JobCategory) */

void zx_hrxml_PreferredPosition_PUSH_JobCategory(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_JobCategory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->JobCategory->gg.g;
  x->JobCategory = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_JobCategory) */

void zx_hrxml_PreferredPosition_REV_JobCategory(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_JobCategory_s* nxt;
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  y = x->JobCategory;
  if (!y) return;
  x->JobCategory = 0;
  while (y) {
    nxt = (struct zx_hrxml_JobCategory_s*)y->gg.g.n;
    y->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_JobCategory) */

void zx_hrxml_PreferredPosition_PUT_JobCategory(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  y = x->JobCategory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->JobCategory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_JobCategory) */

void zx_hrxml_PreferredPosition_ADD_JobCategory(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_JobCategory_s* z)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->JobCategory->gg.g;
    x->JobCategory = z;
    return;
  case -1:
    y = x->JobCategory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_JobCategory) */

void zx_hrxml_PreferredPosition_DEL_JobCategory(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_JobCategory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->JobCategory = (struct zx_hrxml_JobCategory_s*)x->JobCategory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_JobCategory_s*)x->JobCategory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->JobCategory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_JobCategory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_PositionTitle) */

int zx_hrxml_PreferredPosition_NUM_PositionTitle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionTitle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_PositionTitle) */

struct zx_elem_s* zx_hrxml_PreferredPosition_GET_PositionTitle(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PositionTitle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_PositionTitle) */

struct zx_elem_s* zx_hrxml_PreferredPosition_POP_PositionTitle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PositionTitle;
  if (y)
    x->PositionTitle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_PositionTitle) */

void zx_hrxml_PreferredPosition_PUSH_PositionTitle(struct zx_hrxml_PreferredPosition_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PositionTitle->g;
  x->PositionTitle = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_PositionTitle) */

void zx_hrxml_PreferredPosition_REV_PositionTitle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PositionTitle;
  if (!y) return;
  x->PositionTitle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PositionTitle->g;
    x->PositionTitle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_PositionTitle) */

void zx_hrxml_PreferredPosition_PUT_PositionTitle(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PositionTitle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PositionTitle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_PositionTitle) */

void zx_hrxml_PreferredPosition_ADD_PositionTitle(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PositionTitle->g;
    x->PositionTitle = z;
    return;
  case -1:
    y = x->PositionTitle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_PositionTitle) */

void zx_hrxml_PreferredPosition_DEL_PositionTitle(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionTitle = (struct zx_elem_s*)x->PositionTitle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PositionTitle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_PositionClassification) */

int zx_hrxml_PreferredPosition_NUM_PositionClassification(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionClassification; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_PositionClassification) */

struct zx_elem_s* zx_hrxml_PreferredPosition_GET_PositionClassification(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PositionClassification; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_PositionClassification) */

struct zx_elem_s* zx_hrxml_PreferredPosition_POP_PositionClassification(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PositionClassification;
  if (y)
    x->PositionClassification = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_PositionClassification) */

void zx_hrxml_PreferredPosition_PUSH_PositionClassification(struct zx_hrxml_PreferredPosition_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PositionClassification->g;
  x->PositionClassification = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_PositionClassification) */

void zx_hrxml_PreferredPosition_REV_PositionClassification(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PositionClassification;
  if (!y) return;
  x->PositionClassification = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PositionClassification->g;
    x->PositionClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_PositionClassification) */

void zx_hrxml_PreferredPosition_PUT_PositionClassification(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PositionClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PositionClassification = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_PositionClassification) */

void zx_hrxml_PreferredPosition_ADD_PositionClassification(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PositionClassification->g;
    x->PositionClassification = z;
    return;
  case -1:
    y = x->PositionClassification;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionClassification; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_PositionClassification) */

void zx_hrxml_PreferredPosition_DEL_PositionClassification(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionClassification = (struct zx_elem_s*)x->PositionClassification->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PositionClassification;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionClassification; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_PositionSchedule) */

int zx_hrxml_PreferredPosition_NUM_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PositionSchedule_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionSchedule; y; ++n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_PositionSchedule) */

struct zx_hrxml_PositionSchedule_s* zx_hrxml_PreferredPosition_GET_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return 0;
  for (y = x->PositionSchedule; n>=0 && y; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_PositionSchedule) */

struct zx_hrxml_PositionSchedule_s* zx_hrxml_PreferredPosition_POP_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return 0;
  y = x->PositionSchedule;
  if (y)
    x->PositionSchedule = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_PositionSchedule) */

void zx_hrxml_PreferredPosition_PUSH_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_PositionSchedule_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PositionSchedule->gg.g;
  x->PositionSchedule = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_PositionSchedule) */

void zx_hrxml_PreferredPosition_REV_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PositionSchedule_s* nxt;
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return;
  y = x->PositionSchedule;
  if (!y) return;
  x->PositionSchedule = 0;
  while (y) {
    nxt = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n;
    y->gg.g.n = &x->PositionSchedule->gg.g;
    x->PositionSchedule = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_PositionSchedule) */

void zx_hrxml_PreferredPosition_PUT_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PositionSchedule_s* z)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x || !z) return;
  y = x->PositionSchedule;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PositionSchedule = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_PositionSchedule) */

void zx_hrxml_PreferredPosition_ADD_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PositionSchedule_s* z)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PositionSchedule->gg.g;
    x->PositionSchedule = z;
    return;
  case -1:
    y = x->PositionSchedule;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionSchedule; n > 1 && y; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_PositionSchedule) */

void zx_hrxml_PreferredPosition_DEL_PositionSchedule(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PositionSchedule_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionSchedule = (struct zx_hrxml_PositionSchedule_s*)x->PositionSchedule->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PositionSchedule_s*)x->PositionSchedule;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionSchedule; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionSchedule_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Shift) */

int zx_hrxml_PreferredPosition_NUM_Shift(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Shift_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Shift; y; ++n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Shift) */

struct zx_hrxml_Shift_s* zx_hrxml_PreferredPosition_GET_Shift(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return 0;
  for (y = x->Shift; n>=0 && y; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Shift) */

struct zx_hrxml_Shift_s* zx_hrxml_PreferredPosition_POP_Shift(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return 0;
  y = x->Shift;
  if (y)
    x->Shift = (struct zx_hrxml_Shift_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Shift) */

void zx_hrxml_PreferredPosition_PUSH_Shift(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Shift_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Shift->gg.g;
  x->Shift = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Shift) */

void zx_hrxml_PreferredPosition_REV_Shift(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Shift_s* nxt;
  struct zx_hrxml_Shift_s* y;
  if (!x) return;
  y = x->Shift;
  if (!y) return;
  x->Shift = 0;
  while (y) {
    nxt = (struct zx_hrxml_Shift_s*)y->gg.g.n;
    y->gg.g.n = &x->Shift->gg.g;
    x->Shift = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Shift) */

void zx_hrxml_PreferredPosition_PUT_Shift(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Shift_s* z)
{
  struct zx_hrxml_Shift_s* y;
  if (!x || !z) return;
  y = x->Shift;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Shift = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Shift) */

void zx_hrxml_PreferredPosition_ADD_Shift(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Shift_s* z)
{
  struct zx_hrxml_Shift_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Shift->gg.g;
    x->Shift = z;
    return;
  case -1:
    y = x->Shift;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Shift; n > 1 && y; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Shift) */

void zx_hrxml_PreferredPosition_DEL_Shift(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Shift_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Shift = (struct zx_hrxml_Shift_s*)x->Shift->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Shift_s*)x->Shift;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Shift; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Shift_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Competency) */

int zx_hrxml_PreferredPosition_NUM_Competency(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Competency_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Competency; y; ++n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PreferredPosition_GET_Competency(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  for (y = x->Competency; n>=0 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_PreferredPosition_POP_Competency(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  y = x->Competency;
  if (y)
    x->Competency = (struct zx_hrxml_Competency_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Competency) */

void zx_hrxml_PreferredPosition_PUSH_Competency(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Competency_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Competency->gg.g;
  x->Competency = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Competency) */

void zx_hrxml_PreferredPosition_REV_Competency(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Competency_s* nxt;
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  y = x->Competency;
  if (!y) return;
  x->Competency = 0;
  while (y) {
    nxt = (struct zx_hrxml_Competency_s*)y->gg.g.n;
    y->gg.g.n = &x->Competency->gg.g;
    x->Competency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Competency) */

void zx_hrxml_PreferredPosition_PUT_Competency(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  y = x->Competency;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Competency = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Competency) */

void zx_hrxml_PreferredPosition_ADD_Competency(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Competency->gg.g;
    x->Competency = z;
    return;
  case -1:
    y = x->Competency;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Competency) */

void zx_hrxml_PreferredPosition_DEL_Competency(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Competency = (struct zx_hrxml_Competency_s*)x->Competency->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Competency_s*)x->Competency;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_RemunerationPackage) */

int zx_hrxml_PreferredPosition_NUM_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RemunerationPackage; y; ++n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_RemunerationPackage) */

struct zx_hrxml_RemunerationPackage_s* zx_hrxml_PreferredPosition_GET_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return 0;
  for (y = x->RemunerationPackage; n>=0 && y; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_RemunerationPackage) */

struct zx_hrxml_RemunerationPackage_s* zx_hrxml_PreferredPosition_POP_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return 0;
  y = x->RemunerationPackage;
  if (y)
    x->RemunerationPackage = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_RemunerationPackage) */

void zx_hrxml_PreferredPosition_PUSH_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_RemunerationPackage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RemunerationPackage->gg.g;
  x->RemunerationPackage = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_RemunerationPackage) */

void zx_hrxml_PreferredPosition_REV_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_RemunerationPackage_s* nxt;
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return;
  y = x->RemunerationPackage;
  if (!y) return;
  x->RemunerationPackage = 0;
  while (y) {
    nxt = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n;
    y->gg.g.n = &x->RemunerationPackage->gg.g;
    x->RemunerationPackage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_RemunerationPackage) */

void zx_hrxml_PreferredPosition_PUT_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_RemunerationPackage_s* z)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x || !z) return;
  y = x->RemunerationPackage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RemunerationPackage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_RemunerationPackage) */

void zx_hrxml_PreferredPosition_ADD_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_RemunerationPackage_s* z)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RemunerationPackage->gg.g;
    x->RemunerationPackage = z;
    return;
  case -1:
    y = x->RemunerationPackage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RemunerationPackage; n > 1 && y; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_RemunerationPackage) */

void zx_hrxml_PreferredPosition_DEL_RemunerationPackage(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_RemunerationPackage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RemunerationPackage = (struct zx_hrxml_RemunerationPackage_s*)x->RemunerationPackage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RemunerationPackage_s*)x->RemunerationPackage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RemunerationPackage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RemunerationPackage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_WorkStyle) */

int zx_hrxml_PreferredPosition_NUM_WorkStyle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkStyle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_WorkStyle) */

struct zx_elem_s* zx_hrxml_PreferredPosition_GET_WorkStyle(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->WorkStyle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_WorkStyle) */

struct zx_elem_s* zx_hrxml_PreferredPosition_POP_WorkStyle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->WorkStyle;
  if (y)
    x->WorkStyle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_WorkStyle) */

void zx_hrxml_PreferredPosition_PUSH_WorkStyle(struct zx_hrxml_PreferredPosition_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->WorkStyle->g;
  x->WorkStyle = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_WorkStyle) */

void zx_hrxml_PreferredPosition_REV_WorkStyle(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->WorkStyle;
  if (!y) return;
  x->WorkStyle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->WorkStyle->g;
    x->WorkStyle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_WorkStyle) */

void zx_hrxml_PreferredPosition_PUT_WorkStyle(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->WorkStyle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->WorkStyle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_WorkStyle) */

void zx_hrxml_PreferredPosition_ADD_WorkStyle(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->WorkStyle->g;
    x->WorkStyle = z;
    return;
  case -1:
    y = x->WorkStyle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkStyle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_WorkStyle) */

void zx_hrxml_PreferredPosition_DEL_WorkStyle(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkStyle = (struct zx_elem_s*)x->WorkStyle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->WorkStyle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkStyle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_DressCode) */

int zx_hrxml_PreferredPosition_NUM_DressCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DressCode; y; ++n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_PreferredPosition_GET_DressCode(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  for (y = x->DressCode; n>=0 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_DressCode) */

struct zx_hrxml_DressCode_s* zx_hrxml_PreferredPosition_POP_DressCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return 0;
  y = x->DressCode;
  if (y)
    x->DressCode = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_DressCode) */

void zx_hrxml_PreferredPosition_PUSH_DressCode(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_DressCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DressCode->gg.g;
  x->DressCode = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_DressCode) */

void zx_hrxml_PreferredPosition_REV_DressCode(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_DressCode_s* nxt;
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  y = x->DressCode;
  if (!y) return;
  x->DressCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_DressCode_s*)y->gg.g.n;
    y->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_DressCode) */

void zx_hrxml_PreferredPosition_PUT_DressCode(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  y = x->DressCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DressCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_DressCode) */

void zx_hrxml_PreferredPosition_ADD_DressCode(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_DressCode_s* z)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DressCode->gg.g;
    x->DressCode = z;
    return;
  case -1:
    y = x->DressCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_DressCode) */

void zx_hrxml_PreferredPosition_DEL_DressCode(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_DressCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DressCode = (struct zx_hrxml_DressCode_s*)x->DressCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DressCode_s*)x->DressCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DressCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DressCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Travel) */

int zx_hrxml_PreferredPosition_NUM_Travel(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Travel_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Travel; y; ++n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Travel) */

struct zx_hrxml_Travel_s* zx_hrxml_PreferredPosition_GET_Travel(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return 0;
  for (y = x->Travel; n>=0 && y; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Travel) */

struct zx_hrxml_Travel_s* zx_hrxml_PreferredPosition_POP_Travel(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return 0;
  y = x->Travel;
  if (y)
    x->Travel = (struct zx_hrxml_Travel_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Travel) */

void zx_hrxml_PreferredPosition_PUSH_Travel(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Travel_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Travel->gg.g;
  x->Travel = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Travel) */

void zx_hrxml_PreferredPosition_REV_Travel(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Travel_s* nxt;
  struct zx_hrxml_Travel_s* y;
  if (!x) return;
  y = x->Travel;
  if (!y) return;
  x->Travel = 0;
  while (y) {
    nxt = (struct zx_hrxml_Travel_s*)y->gg.g.n;
    y->gg.g.n = &x->Travel->gg.g;
    x->Travel = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Travel) */

void zx_hrxml_PreferredPosition_PUT_Travel(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Travel_s* z)
{
  struct zx_hrxml_Travel_s* y;
  if (!x || !z) return;
  y = x->Travel;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Travel = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Travel) */

void zx_hrxml_PreferredPosition_ADD_Travel(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Travel_s* z)
{
  struct zx_hrxml_Travel_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Travel->gg.g;
    x->Travel = z;
    return;
  case -1:
    y = x->Travel;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Travel; n > 1 && y; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Travel) */

void zx_hrxml_PreferredPosition_DEL_Travel(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Travel_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Travel = (struct zx_hrxml_Travel_s*)x->Travel->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Travel_s*)x->Travel;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Travel; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Travel_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Relocation) */

int zx_hrxml_PreferredPosition_NUM_Relocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Relocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Relocation; y; ++n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Relocation) */

struct zx_hrxml_Relocation_s* zx_hrxml_PreferredPosition_GET_Relocation(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return 0;
  for (y = x->Relocation; n>=0 && y; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Relocation) */

struct zx_hrxml_Relocation_s* zx_hrxml_PreferredPosition_POP_Relocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return 0;
  y = x->Relocation;
  if (y)
    x->Relocation = (struct zx_hrxml_Relocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Relocation) */

void zx_hrxml_PreferredPosition_PUSH_Relocation(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Relocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Relocation->gg.g;
  x->Relocation = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Relocation) */

void zx_hrxml_PreferredPosition_REV_Relocation(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Relocation_s* nxt;
  struct zx_hrxml_Relocation_s* y;
  if (!x) return;
  y = x->Relocation;
  if (!y) return;
  x->Relocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_Relocation_s*)y->gg.g.n;
    y->gg.g.n = &x->Relocation->gg.g;
    x->Relocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Relocation) */

void zx_hrxml_PreferredPosition_PUT_Relocation(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Relocation_s* z)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x || !z) return;
  y = x->Relocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Relocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Relocation) */

void zx_hrxml_PreferredPosition_ADD_Relocation(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Relocation_s* z)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Relocation->gg.g;
    x->Relocation = z;
    return;
  case -1:
    y = x->Relocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Relocation; n > 1 && y; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Relocation) */

void zx_hrxml_PreferredPosition_DEL_Relocation(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Relocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Relocation = (struct zx_hrxml_Relocation_s*)x->Relocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Relocation_s*)x->Relocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Relocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Relocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_PreferredLanguage) */

int zx_hrxml_PreferredPosition_NUM_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PreferredLanguage; y; ++n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_PreferredLanguage) */

struct zx_hrxml_PreferredLanguage_s* zx_hrxml_PreferredPosition_GET_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return 0;
  for (y = x->PreferredLanguage; n>=0 && y; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_PreferredLanguage) */

struct zx_hrxml_PreferredLanguage_s* zx_hrxml_PreferredPosition_POP_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return 0;
  y = x->PreferredLanguage;
  if (y)
    x->PreferredLanguage = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_PreferredLanguage) */

void zx_hrxml_PreferredPosition_PUSH_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_PreferredLanguage_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PreferredLanguage->gg.g;
  x->PreferredLanguage = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_PreferredLanguage) */

void zx_hrxml_PreferredPosition_REV_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_PreferredLanguage_s* nxt;
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return;
  y = x->PreferredLanguage;
  if (!y) return;
  x->PreferredLanguage = 0;
  while (y) {
    nxt = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n;
    y->gg.g.n = &x->PreferredLanguage->gg.g;
    x->PreferredLanguage = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_PreferredLanguage) */

void zx_hrxml_PreferredPosition_PUT_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PreferredLanguage_s* z)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x || !z) return;
  y = x->PreferredLanguage;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PreferredLanguage = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_PreferredLanguage) */

void zx_hrxml_PreferredPosition_ADD_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_PreferredLanguage_s* z)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PreferredLanguage->gg.g;
    x->PreferredLanguage = z;
    return;
  case -1:
    y = x->PreferredLanguage;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredLanguage; n > 1 && y; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_PreferredLanguage) */

void zx_hrxml_PreferredPosition_DEL_PreferredLanguage(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_PreferredLanguage_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PreferredLanguage = (struct zx_hrxml_PreferredLanguage_s*)x->PreferredLanguage->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PreferredLanguage_s*)x->PreferredLanguage;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PreferredLanguage; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PreferredLanguage_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_UserArea) */

int zx_hrxml_PreferredPosition_NUM_UserArea(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PreferredPosition_GET_UserArea(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PreferredPosition_POP_UserArea(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_UserArea) */

void zx_hrxml_PreferredPosition_PUSH_UserArea(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_UserArea) */

void zx_hrxml_PreferredPosition_REV_UserArea(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_UserArea) */

void zx_hrxml_PreferredPosition_PUT_UserArea(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_UserArea) */

void zx_hrxml_PreferredPosition_ADD_UserArea(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_UserArea) */

void zx_hrxml_PreferredPosition_DEL_UserArea(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PreferredPosition_NUM_Commute) */

int zx_hrxml_PreferredPosition_NUM_Commute(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Commute_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Commute; y; ++n, y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PreferredPosition_GET_Commute) */

struct zx_hrxml_Commute_s* zx_hrxml_PreferredPosition_GET_Commute(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Commute_s* y;
  if (!x) return 0;
  for (y = x->Commute; n>=0 && y; --n, y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_POP_Commute) */

struct zx_hrxml_Commute_s* zx_hrxml_PreferredPosition_POP_Commute(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Commute_s* y;
  if (!x) return 0;
  y = x->Commute;
  if (y)
    x->Commute = (struct zx_hrxml_Commute_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PreferredPosition_PUSH_Commute) */

void zx_hrxml_PreferredPosition_PUSH_Commute(struct zx_hrxml_PreferredPosition_s* x, struct zx_hrxml_Commute_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Commute->gg.g;
  x->Commute = z;
}

/* FUNC(zx_hrxml_PreferredPosition_REV_Commute) */

void zx_hrxml_PreferredPosition_REV_Commute(struct zx_hrxml_PreferredPosition_s* x)
{
  struct zx_hrxml_Commute_s* nxt;
  struct zx_hrxml_Commute_s* y;
  if (!x) return;
  y = x->Commute;
  if (!y) return;
  x->Commute = 0;
  while (y) {
    nxt = (struct zx_hrxml_Commute_s*)y->gg.g.n;
    y->gg.g.n = &x->Commute->gg.g;
    x->Commute = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_PUT_Commute) */

void zx_hrxml_PreferredPosition_PUT_Commute(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Commute_s* z)
{
  struct zx_hrxml_Commute_s* y;
  if (!x || !z) return;
  y = x->Commute;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Commute = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PreferredPosition_ADD_Commute) */

void zx_hrxml_PreferredPosition_ADD_Commute(struct zx_hrxml_PreferredPosition_s* x, int n, struct zx_hrxml_Commute_s* z)
{
  struct zx_hrxml_Commute_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Commute->gg.g;
    x->Commute = z;
    return;
  case -1:
    y = x->Commute;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Commute; n > 1 && y; --n, y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PreferredPosition_DEL_Commute) */

void zx_hrxml_PreferredPosition_DEL_Commute(struct zx_hrxml_PreferredPosition_s* x, int n)
{
  struct zx_hrxml_Commute_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Commute = (struct zx_hrxml_Commute_s*)x->Commute->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Commute_s*)x->Commute;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Commute; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Commute_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PrehireRemuneration_NUM_BasePay) */

int zx_hrxml_PrehireRemuneration_NUM_BasePay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_BasePay_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BasePay; y; ++n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PrehireRemuneration_GET_BasePay) */

struct zx_hrxml_BasePay_s* zx_hrxml_PrehireRemuneration_GET_BasePay(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return 0;
  for (y = x->BasePay; n>=0 && y; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_POP_BasePay) */

struct zx_hrxml_BasePay_s* zx_hrxml_PrehireRemuneration_POP_BasePay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return 0;
  y = x->BasePay;
  if (y)
    x->BasePay = (struct zx_hrxml_BasePay_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUSH_BasePay) */

void zx_hrxml_PrehireRemuneration_PUSH_BasePay(struct zx_hrxml_PrehireRemuneration_s* x, struct zx_hrxml_BasePay_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->BasePay->gg.g;
  x->BasePay = z;
}

/* FUNC(zx_hrxml_PrehireRemuneration_REV_BasePay) */

void zx_hrxml_PrehireRemuneration_REV_BasePay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_BasePay_s* nxt;
  struct zx_hrxml_BasePay_s* y;
  if (!x) return;
  y = x->BasePay;
  if (!y) return;
  x->BasePay = 0;
  while (y) {
    nxt = (struct zx_hrxml_BasePay_s*)y->gg.g.n;
    y->gg.g.n = &x->BasePay->gg.g;
    x->BasePay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUT_BasePay) */

void zx_hrxml_PrehireRemuneration_PUT_BasePay(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_BasePay_s* z)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x || !z) return;
  y = x->BasePay;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->BasePay = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_ADD_BasePay) */

void zx_hrxml_PrehireRemuneration_ADD_BasePay(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_BasePay_s* z)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->BasePay->gg.g;
    x->BasePay = z;
    return;
  case -1:
    y = x->BasePay;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BasePay; n > 1 && y; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PrehireRemuneration_DEL_BasePay) */

void zx_hrxml_PrehireRemuneration_DEL_BasePay(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BasePay = (struct zx_hrxml_BasePay_s*)x->BasePay->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_BasePay_s*)x->BasePay;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BasePay; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PrehireRemuneration_NUM_OtherPay) */

int zx_hrxml_PrehireRemuneration_NUM_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_OtherPay_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPay; y; ++n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PrehireRemuneration_GET_OtherPay) */

struct zx_hrxml_OtherPay_s* zx_hrxml_PrehireRemuneration_GET_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return 0;
  for (y = x->OtherPay; n>=0 && y; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_POP_OtherPay) */

struct zx_hrxml_OtherPay_s* zx_hrxml_PrehireRemuneration_POP_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return 0;
  y = x->OtherPay;
  if (y)
    x->OtherPay = (struct zx_hrxml_OtherPay_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUSH_OtherPay) */

void zx_hrxml_PrehireRemuneration_PUSH_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x, struct zx_hrxml_OtherPay_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherPay->gg.g;
  x->OtherPay = z;
}

/* FUNC(zx_hrxml_PrehireRemuneration_REV_OtherPay) */

void zx_hrxml_PrehireRemuneration_REV_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_OtherPay_s* nxt;
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return;
  y = x->OtherPay;
  if (!y) return;
  x->OtherPay = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherPay_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherPay->gg.g;
    x->OtherPay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUT_OtherPay) */

void zx_hrxml_PrehireRemuneration_PUT_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_OtherPay_s* z)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x || !z) return;
  y = x->OtherPay;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherPay = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_ADD_OtherPay) */

void zx_hrxml_PrehireRemuneration_ADD_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_OtherPay_s* z)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherPay->gg.g;
    x->OtherPay = z;
    return;
  case -1:
    y = x->OtherPay;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPay; n > 1 && y; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PrehireRemuneration_DEL_OtherPay) */

void zx_hrxml_PrehireRemuneration_DEL_OtherPay(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPay = (struct zx_hrxml_OtherPay_s*)x->OtherPay->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherPay_s*)x->OtherPay;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPay; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PrehireRemuneration_NUM_Benefits) */

int zx_hrxml_PrehireRemuneration_NUM_Benefits(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_Benefits_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Benefits; y; ++n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PrehireRemuneration_GET_Benefits) */

struct zx_hrxml_Benefits_s* zx_hrxml_PrehireRemuneration_GET_Benefits(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return 0;
  for (y = x->Benefits; n>=0 && y; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_POP_Benefits) */

struct zx_hrxml_Benefits_s* zx_hrxml_PrehireRemuneration_POP_Benefits(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return 0;
  y = x->Benefits;
  if (y)
    x->Benefits = (struct zx_hrxml_Benefits_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUSH_Benefits) */

void zx_hrxml_PrehireRemuneration_PUSH_Benefits(struct zx_hrxml_PrehireRemuneration_s* x, struct zx_hrxml_Benefits_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Benefits->gg.g;
  x->Benefits = z;
}

/* FUNC(zx_hrxml_PrehireRemuneration_REV_Benefits) */

void zx_hrxml_PrehireRemuneration_REV_Benefits(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_Benefits_s* nxt;
  struct zx_hrxml_Benefits_s* y;
  if (!x) return;
  y = x->Benefits;
  if (!y) return;
  x->Benefits = 0;
  while (y) {
    nxt = (struct zx_hrxml_Benefits_s*)y->gg.g.n;
    y->gg.g.n = &x->Benefits->gg.g;
    x->Benefits = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUT_Benefits) */

void zx_hrxml_PrehireRemuneration_PUT_Benefits(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_Benefits_s* z)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x || !z) return;
  y = x->Benefits;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Benefits = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_ADD_Benefits) */

void zx_hrxml_PrehireRemuneration_ADD_Benefits(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_Benefits_s* z)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Benefits->gg.g;
    x->Benefits = z;
    return;
  case -1:
    y = x->Benefits;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Benefits; n > 1 && y; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PrehireRemuneration_DEL_Benefits) */

void zx_hrxml_PrehireRemuneration_DEL_Benefits(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Benefits = (struct zx_hrxml_Benefits_s*)x->Benefits->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Benefits_s*)x->Benefits;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Benefits; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PrehireRemuneration_NUM_UserArea) */

int zx_hrxml_PrehireRemuneration_NUM_UserArea(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PrehireRemuneration_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PrehireRemuneration_GET_UserArea(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_PrehireRemuneration_POP_UserArea(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUSH_UserArea) */

void zx_hrxml_PrehireRemuneration_PUSH_UserArea(struct zx_hrxml_PrehireRemuneration_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_PrehireRemuneration_REV_UserArea) */

void zx_hrxml_PrehireRemuneration_REV_UserArea(struct zx_hrxml_PrehireRemuneration_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_PUT_UserArea) */

void zx_hrxml_PrehireRemuneration_PUT_UserArea(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PrehireRemuneration_ADD_UserArea) */

void zx_hrxml_PrehireRemuneration_ADD_UserArea(struct zx_hrxml_PrehireRemuneration_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PrehireRemuneration_DEL_UserArea) */

void zx_hrxml_PrehireRemuneration_DEL_UserArea(struct zx_hrxml_PrehireRemuneration_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif













#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ProfessionalAssociations_NUM_Association) */

int zx_hrxml_ProfessionalAssociations_NUM_Association(struct zx_hrxml_ProfessionalAssociations_s* x)
{
  struct zx_hrxml_Association_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Association; y; ++n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ProfessionalAssociations_GET_Association) */

struct zx_hrxml_Association_s* zx_hrxml_ProfessionalAssociations_GET_Association(struct zx_hrxml_ProfessionalAssociations_s* x, int n)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return 0;
  for (y = x->Association; n>=0 && y; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ProfessionalAssociations_POP_Association) */

struct zx_hrxml_Association_s* zx_hrxml_ProfessionalAssociations_POP_Association(struct zx_hrxml_ProfessionalAssociations_s* x)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return 0;
  y = x->Association;
  if (y)
    x->Association = (struct zx_hrxml_Association_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ProfessionalAssociations_PUSH_Association) */

void zx_hrxml_ProfessionalAssociations_PUSH_Association(struct zx_hrxml_ProfessionalAssociations_s* x, struct zx_hrxml_Association_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Association->gg.g;
  x->Association = z;
}

/* FUNC(zx_hrxml_ProfessionalAssociations_REV_Association) */

void zx_hrxml_ProfessionalAssociations_REV_Association(struct zx_hrxml_ProfessionalAssociations_s* x)
{
  struct zx_hrxml_Association_s* nxt;
  struct zx_hrxml_Association_s* y;
  if (!x) return;
  y = x->Association;
  if (!y) return;
  x->Association = 0;
  while (y) {
    nxt = (struct zx_hrxml_Association_s*)y->gg.g.n;
    y->gg.g.n = &x->Association->gg.g;
    x->Association = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ProfessionalAssociations_PUT_Association) */

void zx_hrxml_ProfessionalAssociations_PUT_Association(struct zx_hrxml_ProfessionalAssociations_s* x, int n, struct zx_hrxml_Association_s* z)
{
  struct zx_hrxml_Association_s* y;
  if (!x || !z) return;
  y = x->Association;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Association = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ProfessionalAssociations_ADD_Association) */

void zx_hrxml_ProfessionalAssociations_ADD_Association(struct zx_hrxml_ProfessionalAssociations_s* x, int n, struct zx_hrxml_Association_s* z)
{
  struct zx_hrxml_Association_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Association->gg.g;
    x->Association = z;
    return;
  case -1:
    y = x->Association;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Association; n > 1 && y; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ProfessionalAssociations_DEL_Association) */

void zx_hrxml_ProfessionalAssociations_DEL_Association(struct zx_hrxml_ProfessionalAssociations_s* x, int n)
{
  struct zx_hrxml_Association_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Association = (struct zx_hrxml_Association_s*)x->Association->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Association_s*)x->Association;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Association; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Association_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ProfileId_NUM_IdValue) */

int zx_hrxml_ProfileId_NUM_IdValue(struct zx_hrxml_ProfileId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ProfileId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ProfileId_GET_IdValue(struct zx_hrxml_ProfileId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ProfileId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ProfileId_POP_IdValue(struct zx_hrxml_ProfileId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ProfileId_PUSH_IdValue) */

void zx_hrxml_ProfileId_PUSH_IdValue(struct zx_hrxml_ProfileId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_ProfileId_REV_IdValue) */

void zx_hrxml_ProfileId_REV_IdValue(struct zx_hrxml_ProfileId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ProfileId_PUT_IdValue) */

void zx_hrxml_ProfileId_PUT_IdValue(struct zx_hrxml_ProfileId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ProfileId_ADD_IdValue) */

void zx_hrxml_ProfileId_ADD_IdValue(struct zx_hrxml_ProfileId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ProfileId_DEL_IdValue) */

void zx_hrxml_ProfileId_DEL_IdValue(struct zx_hrxml_ProfileId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ProfileId_GET_idOwner) */
struct zx_str* zx_hrxml_ProfileId_GET_idOwner(struct zx_hrxml_ProfileId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_ProfileId_PUT_idOwner) */
void zx_hrxml_ProfileId_PUT_idOwner(struct zx_hrxml_ProfileId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_ProfileId_GET_validFrom) */
struct zx_str* zx_hrxml_ProfileId_GET_validFrom(struct zx_hrxml_ProfileId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_ProfileId_PUT_validFrom) */
void zx_hrxml_ProfileId_PUT_validFrom(struct zx_hrxml_ProfileId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_ProfileId_GET_validTo) */
struct zx_str* zx_hrxml_ProfileId_GET_validTo(struct zx_hrxml_ProfileId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_ProfileId_PUT_validTo) */
void zx_hrxml_ProfileId_PUT_validTo(struct zx_hrxml_ProfileId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ProgramId_NUM_IdValue) */

int zx_hrxml_ProgramId_NUM_IdValue(struct zx_hrxml_ProgramId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ProgramId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ProgramId_GET_IdValue(struct zx_hrxml_ProgramId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ProgramId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ProgramId_POP_IdValue(struct zx_hrxml_ProgramId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ProgramId_PUSH_IdValue) */

void zx_hrxml_ProgramId_PUSH_IdValue(struct zx_hrxml_ProgramId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_ProgramId_REV_IdValue) */

void zx_hrxml_ProgramId_REV_IdValue(struct zx_hrxml_ProgramId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ProgramId_PUT_IdValue) */

void zx_hrxml_ProgramId_PUT_IdValue(struct zx_hrxml_ProgramId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ProgramId_ADD_IdValue) */

void zx_hrxml_ProgramId_ADD_IdValue(struct zx_hrxml_ProgramId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ProgramId_DEL_IdValue) */

void zx_hrxml_ProgramId_DEL_IdValue(struct zx_hrxml_ProgramId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ProgramId_GET_idOwner) */
struct zx_str* zx_hrxml_ProgramId_GET_idOwner(struct zx_hrxml_ProgramId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_ProgramId_PUT_idOwner) */
void zx_hrxml_ProgramId_PUT_idOwner(struct zx_hrxml_ProgramId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_ProgramId_GET_validFrom) */
struct zx_str* zx_hrxml_ProgramId_GET_validFrom(struct zx_hrxml_ProgramId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_ProgramId_PUT_validFrom) */
void zx_hrxml_ProgramId_PUT_validFrom(struct zx_hrxml_ProgramId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_ProgramId_GET_validTo) */
struct zx_str* zx_hrxml_ProgramId_GET_validTo(struct zx_hrxml_ProgramId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_ProgramId_PUT_validTo) */
void zx_hrxml_ProgramId_PUT_validTo(struct zx_hrxml_ProgramId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationDate_NUM_AnyDate) */

int zx_hrxml_PublicationDate_NUM_AnyDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_PublicationDate_GET_AnyDate(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_PublicationDate_POP_AnyDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_PUSH_AnyDate) */

void zx_hrxml_PublicationDate_PUSH_AnyDate(struct zx_hrxml_PublicationDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_PublicationDate_REV_AnyDate) */

void zx_hrxml_PublicationDate_REV_AnyDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationDate_PUT_AnyDate) */

void zx_hrxml_PublicationDate_PUT_AnyDate(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PublicationDate_ADD_AnyDate) */

void zx_hrxml_PublicationDate_ADD_AnyDate(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PublicationDate_DEL_AnyDate) */

void zx_hrxml_PublicationDate_DEL_AnyDate(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationDate_NUM_YearMonth) */

int zx_hrxml_PublicationDate_NUM_YearMonth(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_PublicationDate_GET_YearMonth(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_PublicationDate_POP_YearMonth(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_PUSH_YearMonth) */

void zx_hrxml_PublicationDate_PUSH_YearMonth(struct zx_hrxml_PublicationDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_PublicationDate_REV_YearMonth) */

void zx_hrxml_PublicationDate_REV_YearMonth(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationDate_PUT_YearMonth) */

void zx_hrxml_PublicationDate_PUT_YearMonth(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PublicationDate_ADD_YearMonth) */

void zx_hrxml_PublicationDate_ADD_YearMonth(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PublicationDate_DEL_YearMonth) */

void zx_hrxml_PublicationDate_DEL_YearMonth(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationDate_NUM_Year) */

int zx_hrxml_PublicationDate_NUM_Year(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationDate_GET_Year) */

struct zx_elem_s* zx_hrxml_PublicationDate_GET_Year(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_POP_Year) */

struct zx_elem_s* zx_hrxml_PublicationDate_POP_Year(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_PUSH_Year) */

void zx_hrxml_PublicationDate_PUSH_Year(struct zx_hrxml_PublicationDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_PublicationDate_REV_Year) */

void zx_hrxml_PublicationDate_REV_Year(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationDate_PUT_Year) */

void zx_hrxml_PublicationDate_PUT_Year(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PublicationDate_ADD_Year) */

void zx_hrxml_PublicationDate_ADD_Year(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PublicationDate_DEL_Year) */

void zx_hrxml_PublicationDate_DEL_Year(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationDate_NUM_MonthDay) */

int zx_hrxml_PublicationDate_NUM_MonthDay(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_PublicationDate_GET_MonthDay(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_PublicationDate_POP_MonthDay(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_PUSH_MonthDay) */

void zx_hrxml_PublicationDate_PUSH_MonthDay(struct zx_hrxml_PublicationDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_PublicationDate_REV_MonthDay) */

void zx_hrxml_PublicationDate_REV_MonthDay(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationDate_PUT_MonthDay) */

void zx_hrxml_PublicationDate_PUT_MonthDay(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PublicationDate_ADD_MonthDay) */

void zx_hrxml_PublicationDate_ADD_MonthDay(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PublicationDate_DEL_MonthDay) */

void zx_hrxml_PublicationDate_DEL_MonthDay(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationDate_NUM_StringDate) */

int zx_hrxml_PublicationDate_NUM_StringDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_PublicationDate_GET_StringDate(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_PublicationDate_POP_StringDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationDate_PUSH_StringDate) */

void zx_hrxml_PublicationDate_PUSH_StringDate(struct zx_hrxml_PublicationDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_PublicationDate_REV_StringDate) */

void zx_hrxml_PublicationDate_REV_StringDate(struct zx_hrxml_PublicationDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationDate_PUT_StringDate) */

void zx_hrxml_PublicationDate_PUT_StringDate(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_PublicationDate_ADD_StringDate) */

void zx_hrxml_PublicationDate_ADD_StringDate(struct zx_hrxml_PublicationDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_PublicationDate_DEL_StringDate) */

void zx_hrxml_PublicationDate_DEL_StringDate(struct zx_hrxml_PublicationDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_PublicationDate_GET_dateDescription) */
struct zx_str* zx_hrxml_PublicationDate_GET_dateDescription(struct zx_hrxml_PublicationDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_PublicationDate_PUT_dateDescription) */
void zx_hrxml_PublicationDate_PUT_dateDescription(struct zx_hrxml_PublicationDate_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationHistory_NUM_FormattedPublicationDescription) */

int zx_hrxml_PublicationHistory_NUM_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedPublicationDescription; y; ++n, y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationHistory_GET_FormattedPublicationDescription) */

struct zx_hrxml_FormattedPublicationDescription_s* zx_hrxml_PublicationHistory_GET_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x) return 0;
  for (y = x->FormattedPublicationDescription; n>=0 && y; --n, y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_POP_FormattedPublicationDescription) */

struct zx_hrxml_FormattedPublicationDescription_s* zx_hrxml_PublicationHistory_POP_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x) return 0;
  y = x->FormattedPublicationDescription;
  if (y)
    x->FormattedPublicationDescription = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_PUSH_FormattedPublicationDescription) */

void zx_hrxml_PublicationHistory_PUSH_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x, struct zx_hrxml_FormattedPublicationDescription_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->FormattedPublicationDescription->gg.g;
  x->FormattedPublicationDescription = z;
}

/* FUNC(zx_hrxml_PublicationHistory_REV_FormattedPublicationDescription) */

void zx_hrxml_PublicationHistory_REV_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_FormattedPublicationDescription_s* nxt;
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x) return;
  y = x->FormattedPublicationDescription;
  if (!y) return;
  x->FormattedPublicationDescription = 0;
  while (y) {
    nxt = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n;
    y->gg.g.n = &x->FormattedPublicationDescription->gg.g;
    x->FormattedPublicationDescription = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_PUT_FormattedPublicationDescription) */

void zx_hrxml_PublicationHistory_PUT_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_FormattedPublicationDescription_s* z)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x || !z) return;
  y = x->FormattedPublicationDescription;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->FormattedPublicationDescription = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_ADD_FormattedPublicationDescription) */

void zx_hrxml_PublicationHistory_ADD_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_FormattedPublicationDescription_s* z)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->FormattedPublicationDescription->gg.g;
    x->FormattedPublicationDescription = z;
    return;
  case -1:
    y = x->FormattedPublicationDescription;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FormattedPublicationDescription; n > 1 && y; --n, y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PublicationHistory_DEL_FormattedPublicationDescription) */

void zx_hrxml_PublicationHistory_DEL_FormattedPublicationDescription(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_FormattedPublicationDescription_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedPublicationDescription = (struct zx_hrxml_FormattedPublicationDescription_s*)x->FormattedPublicationDescription->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_FormattedPublicationDescription_s*)x->FormattedPublicationDescription;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->FormattedPublicationDescription; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_FormattedPublicationDescription_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationHistory_NUM_Article) */

int zx_hrxml_PublicationHistory_NUM_Article(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Article_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Article; y; ++n, y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationHistory_GET_Article) */

struct zx_hrxml_Article_s* zx_hrxml_PublicationHistory_GET_Article(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_Article_s* y;
  if (!x) return 0;
  for (y = x->Article; n>=0 && y; --n, y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_POP_Article) */

struct zx_hrxml_Article_s* zx_hrxml_PublicationHistory_POP_Article(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Article_s* y;
  if (!x) return 0;
  y = x->Article;
  if (y)
    x->Article = (struct zx_hrxml_Article_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_PUSH_Article) */

void zx_hrxml_PublicationHistory_PUSH_Article(struct zx_hrxml_PublicationHistory_s* x, struct zx_hrxml_Article_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Article->gg.g;
  x->Article = z;
}

/* FUNC(zx_hrxml_PublicationHistory_REV_Article) */

void zx_hrxml_PublicationHistory_REV_Article(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Article_s* nxt;
  struct zx_hrxml_Article_s* y;
  if (!x) return;
  y = x->Article;
  if (!y) return;
  x->Article = 0;
  while (y) {
    nxt = (struct zx_hrxml_Article_s*)y->gg.g.n;
    y->gg.g.n = &x->Article->gg.g;
    x->Article = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_PUT_Article) */

void zx_hrxml_PublicationHistory_PUT_Article(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_Article_s* z)
{
  struct zx_hrxml_Article_s* y;
  if (!x || !z) return;
  y = x->Article;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Article = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_ADD_Article) */

void zx_hrxml_PublicationHistory_ADD_Article(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_Article_s* z)
{
  struct zx_hrxml_Article_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Article->gg.g;
    x->Article = z;
    return;
  case -1:
    y = x->Article;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Article; n > 1 && y; --n, y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PublicationHistory_DEL_Article) */

void zx_hrxml_PublicationHistory_DEL_Article(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_Article_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Article = (struct zx_hrxml_Article_s*)x->Article->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Article_s*)x->Article;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Article; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Article_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationHistory_NUM_Book) */

int zx_hrxml_PublicationHistory_NUM_Book(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Book_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Book; y; ++n, y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationHistory_GET_Book) */

struct zx_hrxml_Book_s* zx_hrxml_PublicationHistory_GET_Book(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_Book_s* y;
  if (!x) return 0;
  for (y = x->Book; n>=0 && y; --n, y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_POP_Book) */

struct zx_hrxml_Book_s* zx_hrxml_PublicationHistory_POP_Book(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Book_s* y;
  if (!x) return 0;
  y = x->Book;
  if (y)
    x->Book = (struct zx_hrxml_Book_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_PUSH_Book) */

void zx_hrxml_PublicationHistory_PUSH_Book(struct zx_hrxml_PublicationHistory_s* x, struct zx_hrxml_Book_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Book->gg.g;
  x->Book = z;
}

/* FUNC(zx_hrxml_PublicationHistory_REV_Book) */

void zx_hrxml_PublicationHistory_REV_Book(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_Book_s* nxt;
  struct zx_hrxml_Book_s* y;
  if (!x) return;
  y = x->Book;
  if (!y) return;
  x->Book = 0;
  while (y) {
    nxt = (struct zx_hrxml_Book_s*)y->gg.g.n;
    y->gg.g.n = &x->Book->gg.g;
    x->Book = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_PUT_Book) */

void zx_hrxml_PublicationHistory_PUT_Book(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_Book_s* z)
{
  struct zx_hrxml_Book_s* y;
  if (!x || !z) return;
  y = x->Book;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Book = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_ADD_Book) */

void zx_hrxml_PublicationHistory_ADD_Book(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_Book_s* z)
{
  struct zx_hrxml_Book_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Book->gg.g;
    x->Book = z;
    return;
  case -1:
    y = x->Book;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Book; n > 1 && y; --n, y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PublicationHistory_DEL_Book) */

void zx_hrxml_PublicationHistory_DEL_Book(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_Book_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Book = (struct zx_hrxml_Book_s*)x->Book->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Book_s*)x->Book;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Book; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Book_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationHistory_NUM_ConferencePaper) */

int zx_hrxml_PublicationHistory_NUM_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_ConferencePaper_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ConferencePaper; y; ++n, y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationHistory_GET_ConferencePaper) */

struct zx_hrxml_ConferencePaper_s* zx_hrxml_PublicationHistory_GET_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x) return 0;
  for (y = x->ConferencePaper; n>=0 && y; --n, y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_POP_ConferencePaper) */

struct zx_hrxml_ConferencePaper_s* zx_hrxml_PublicationHistory_POP_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x) return 0;
  y = x->ConferencePaper;
  if (y)
    x->ConferencePaper = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_PUSH_ConferencePaper) */

void zx_hrxml_PublicationHistory_PUSH_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x, struct zx_hrxml_ConferencePaper_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ConferencePaper->gg.g;
  x->ConferencePaper = z;
}

/* FUNC(zx_hrxml_PublicationHistory_REV_ConferencePaper) */

void zx_hrxml_PublicationHistory_REV_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_ConferencePaper_s* nxt;
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x) return;
  y = x->ConferencePaper;
  if (!y) return;
  x->ConferencePaper = 0;
  while (y) {
    nxt = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n;
    y->gg.g.n = &x->ConferencePaper->gg.g;
    x->ConferencePaper = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_PUT_ConferencePaper) */

void zx_hrxml_PublicationHistory_PUT_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_ConferencePaper_s* z)
{
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x || !z) return;
  y = x->ConferencePaper;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ConferencePaper = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_ADD_ConferencePaper) */

void zx_hrxml_PublicationHistory_ADD_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_ConferencePaper_s* z)
{
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ConferencePaper->gg.g;
    x->ConferencePaper = z;
    return;
  case -1:
    y = x->ConferencePaper;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ConferencePaper; n > 1 && y; --n, y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PublicationHistory_DEL_ConferencePaper) */

void zx_hrxml_PublicationHistory_DEL_ConferencePaper(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_ConferencePaper_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ConferencePaper = (struct zx_hrxml_ConferencePaper_s*)x->ConferencePaper->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ConferencePaper_s*)x->ConferencePaper;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ConferencePaper; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ConferencePaper_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_PublicationHistory_NUM_OtherPublication) */

int zx_hrxml_PublicationHistory_NUM_OtherPublication(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_OtherPublication_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPublication; y; ++n, y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_PublicationHistory_GET_OtherPublication) */

struct zx_hrxml_OtherPublication_s* zx_hrxml_PublicationHistory_GET_OtherPublication(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_OtherPublication_s* y;
  if (!x) return 0;
  for (y = x->OtherPublication; n>=0 && y; --n, y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_POP_OtherPublication) */

struct zx_hrxml_OtherPublication_s* zx_hrxml_PublicationHistory_POP_OtherPublication(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_OtherPublication_s* y;
  if (!x) return 0;
  y = x->OtherPublication;
  if (y)
    x->OtherPublication = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_PublicationHistory_PUSH_OtherPublication) */

void zx_hrxml_PublicationHistory_PUSH_OtherPublication(struct zx_hrxml_PublicationHistory_s* x, struct zx_hrxml_OtherPublication_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherPublication->gg.g;
  x->OtherPublication = z;
}

/* FUNC(zx_hrxml_PublicationHistory_REV_OtherPublication) */

void zx_hrxml_PublicationHistory_REV_OtherPublication(struct zx_hrxml_PublicationHistory_s* x)
{
  struct zx_hrxml_OtherPublication_s* nxt;
  struct zx_hrxml_OtherPublication_s* y;
  if (!x) return;
  y = x->OtherPublication;
  if (!y) return;
  x->OtherPublication = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherPublication->gg.g;
    x->OtherPublication = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_PUT_OtherPublication) */

void zx_hrxml_PublicationHistory_PUT_OtherPublication(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_OtherPublication_s* z)
{
  struct zx_hrxml_OtherPublication_s* y;
  if (!x || !z) return;
  y = x->OtherPublication;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherPublication = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_PublicationHistory_ADD_OtherPublication) */

void zx_hrxml_PublicationHistory_ADD_OtherPublication(struct zx_hrxml_PublicationHistory_s* x, int n, struct zx_hrxml_OtherPublication_s* z)
{
  struct zx_hrxml_OtherPublication_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherPublication->gg.g;
    x->OtherPublication = z;
    return;
  case -1:
    y = x->OtherPublication;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPublication; n > 1 && y; --n, y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_PublicationHistory_DEL_OtherPublication) */

void zx_hrxml_PublicationHistory_DEL_OtherPublication(struct zx_hrxml_PublicationHistory_s* x, int n)
{
  struct zx_hrxml_OtherPublication_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPublication = (struct zx_hrxml_OtherPublication_s*)x->OtherPublication->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherPublication_s*)x->OtherPublication;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPublication; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPublication_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif













#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Qualifications_NUM_QualificationSummary) */

int zx_hrxml_Qualifications_NUM_QualificationSummary(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->QualificationSummary; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Qualifications_GET_QualificationSummary) */

struct zx_elem_s* zx_hrxml_Qualifications_GET_QualificationSummary(struct zx_hrxml_Qualifications_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->QualificationSummary; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Qualifications_POP_QualificationSummary) */

struct zx_elem_s* zx_hrxml_Qualifications_POP_QualificationSummary(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->QualificationSummary;
  if (y)
    x->QualificationSummary = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Qualifications_PUSH_QualificationSummary) */

void zx_hrxml_Qualifications_PUSH_QualificationSummary(struct zx_hrxml_Qualifications_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->QualificationSummary->g;
  x->QualificationSummary = z;
}

/* FUNC(zx_hrxml_Qualifications_REV_QualificationSummary) */

void zx_hrxml_Qualifications_REV_QualificationSummary(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->QualificationSummary;
  if (!y) return;
  x->QualificationSummary = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->QualificationSummary->g;
    x->QualificationSummary = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Qualifications_PUT_QualificationSummary) */

void zx_hrxml_Qualifications_PUT_QualificationSummary(struct zx_hrxml_Qualifications_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->QualificationSummary;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->QualificationSummary = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Qualifications_ADD_QualificationSummary) */

void zx_hrxml_Qualifications_ADD_QualificationSummary(struct zx_hrxml_Qualifications_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->QualificationSummary->g;
    x->QualificationSummary = z;
    return;
  case -1:
    y = x->QualificationSummary;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->QualificationSummary; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Qualifications_DEL_QualificationSummary) */

void zx_hrxml_Qualifications_DEL_QualificationSummary(struct zx_hrxml_Qualifications_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->QualificationSummary = (struct zx_elem_s*)x->QualificationSummary->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->QualificationSummary;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->QualificationSummary; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Qualifications_NUM_Competency) */

int zx_hrxml_Qualifications_NUM_Competency(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_hrxml_Competency_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Competency; y; ++n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Qualifications_GET_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_Qualifications_GET_Competency(struct zx_hrxml_Qualifications_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  for (y = x->Competency; n>=0 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Qualifications_POP_Competency) */

struct zx_hrxml_Competency_s* zx_hrxml_Qualifications_POP_Competency(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return 0;
  y = x->Competency;
  if (y)
    x->Competency = (struct zx_hrxml_Competency_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Qualifications_PUSH_Competency) */

void zx_hrxml_Qualifications_PUSH_Competency(struct zx_hrxml_Qualifications_s* x, struct zx_hrxml_Competency_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Competency->gg.g;
  x->Competency = z;
}

/* FUNC(zx_hrxml_Qualifications_REV_Competency) */

void zx_hrxml_Qualifications_REV_Competency(struct zx_hrxml_Qualifications_s* x)
{
  struct zx_hrxml_Competency_s* nxt;
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  y = x->Competency;
  if (!y) return;
  x->Competency = 0;
  while (y) {
    nxt = (struct zx_hrxml_Competency_s*)y->gg.g.n;
    y->gg.g.n = &x->Competency->gg.g;
    x->Competency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Qualifications_PUT_Competency) */

void zx_hrxml_Qualifications_PUT_Competency(struct zx_hrxml_Qualifications_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  y = x->Competency;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Competency = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Qualifications_ADD_Competency) */

void zx_hrxml_Qualifications_ADD_Competency(struct zx_hrxml_Qualifications_s* x, int n, struct zx_hrxml_Competency_s* z)
{
  struct zx_hrxml_Competency_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Competency->gg.g;
    x->Competency = z;
    return;
  case -1:
    y = x->Competency;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Qualifications_DEL_Competency) */

void zx_hrxml_Qualifications_DEL_Competency(struct zx_hrxml_Qualifications_s* x, int n)
{
  struct zx_hrxml_Competency_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Competency = (struct zx_hrxml_Competency_s*)x->Competency->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Competency_s*)x->Competency;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Competency; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Competency_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankAchieved_NUM_StartRank) */

int zx_hrxml_RankAchieved_NUM_StartRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartRank; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankAchieved_GET_StartRank) */

struct zx_elem_s* zx_hrxml_RankAchieved_GET_StartRank(struct zx_hrxml_RankAchieved_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StartRank; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankAchieved_POP_StartRank) */

struct zx_elem_s* zx_hrxml_RankAchieved_POP_StartRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StartRank;
  if (y)
    x->StartRank = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RankAchieved_PUSH_StartRank) */

void zx_hrxml_RankAchieved_PUSH_StartRank(struct zx_hrxml_RankAchieved_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StartRank->g;
  x->StartRank = z;
}

/* FUNC(zx_hrxml_RankAchieved_REV_StartRank) */

void zx_hrxml_RankAchieved_REV_StartRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StartRank;
  if (!y) return;
  x->StartRank = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StartRank->g;
    x->StartRank = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankAchieved_PUT_StartRank) */

void zx_hrxml_RankAchieved_PUT_StartRank(struct zx_hrxml_RankAchieved_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StartRank;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StartRank = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RankAchieved_ADD_StartRank) */

void zx_hrxml_RankAchieved_ADD_StartRank(struct zx_hrxml_RankAchieved_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StartRank->g;
    x->StartRank = z;
    return;
  case -1:
    y = x->StartRank;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StartRank; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RankAchieved_DEL_StartRank) */

void zx_hrxml_RankAchieved_DEL_StartRank(struct zx_hrxml_RankAchieved_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartRank = (struct zx_elem_s*)x->StartRank->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StartRank;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StartRank; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankAchieved_NUM_CurrentOrEndRank) */

int zx_hrxml_RankAchieved_NUM_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CurrentOrEndRank; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankAchieved_GET_CurrentOrEndRank) */

struct zx_elem_s* zx_hrxml_RankAchieved_GET_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CurrentOrEndRank; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankAchieved_POP_CurrentOrEndRank) */

struct zx_elem_s* zx_hrxml_RankAchieved_POP_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CurrentOrEndRank;
  if (y)
    x->CurrentOrEndRank = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RankAchieved_PUSH_CurrentOrEndRank) */

void zx_hrxml_RankAchieved_PUSH_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CurrentOrEndRank->g;
  x->CurrentOrEndRank = z;
}

/* FUNC(zx_hrxml_RankAchieved_REV_CurrentOrEndRank) */

void zx_hrxml_RankAchieved_REV_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CurrentOrEndRank;
  if (!y) return;
  x->CurrentOrEndRank = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CurrentOrEndRank->g;
    x->CurrentOrEndRank = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankAchieved_PUT_CurrentOrEndRank) */

void zx_hrxml_RankAchieved_PUT_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CurrentOrEndRank;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CurrentOrEndRank = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RankAchieved_ADD_CurrentOrEndRank) */

void zx_hrxml_RankAchieved_ADD_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CurrentOrEndRank->g;
    x->CurrentOrEndRank = z;
    return;
  case -1:
    y = x->CurrentOrEndRank;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CurrentOrEndRank; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RankAchieved_DEL_CurrentOrEndRank) */

void zx_hrxml_RankAchieved_DEL_CurrentOrEndRank(struct zx_hrxml_RankAchieved_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CurrentOrEndRank = (struct zx_elem_s*)x->CurrentOrEndRank->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CurrentOrEndRank;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CurrentOrEndRank; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_CriterionName) */

int zx_hrxml_RankedResult_NUM_CriterionName(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CriterionName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_CriterionName) */

struct zx_elem_s* zx_hrxml_RankedResult_GET_CriterionName(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CriterionName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_CriterionName) */

struct zx_elem_s* zx_hrxml_RankedResult_POP_CriterionName(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CriterionName;
  if (y)
    x->CriterionName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_CriterionName) */

void zx_hrxml_RankedResult_PUSH_CriterionName(struct zx_hrxml_RankedResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CriterionName->g;
  x->CriterionName = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_CriterionName) */

void zx_hrxml_RankedResult_REV_CriterionName(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CriterionName;
  if (!y) return;
  x->CriterionName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CriterionName->g;
    x->CriterionName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_CriterionName) */

void zx_hrxml_RankedResult_PUT_CriterionName(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CriterionName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CriterionName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_CriterionName) */

void zx_hrxml_RankedResult_ADD_CriterionName(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CriterionName->g;
    x->CriterionName = z;
    return;
  case -1:
    y = x->CriterionName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_CriterionName) */

void zx_hrxml_RankedResult_DEL_CriterionName(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CriterionName = (struct zx_elem_s*)x->CriterionName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CriterionName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_Requested) */

int zx_hrxml_RankedResult_NUM_Requested(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Requested; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_Requested) */

struct zx_elem_s* zx_hrxml_RankedResult_GET_Requested(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Requested; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_Requested) */

struct zx_elem_s* zx_hrxml_RankedResult_POP_Requested(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Requested;
  if (y)
    x->Requested = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_Requested) */

void zx_hrxml_RankedResult_PUSH_Requested(struct zx_hrxml_RankedResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Requested->g;
  x->Requested = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_Requested) */

void zx_hrxml_RankedResult_REV_Requested(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Requested;
  if (!y) return;
  x->Requested = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Requested->g;
    x->Requested = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_Requested) */

void zx_hrxml_RankedResult_PUT_Requested(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Requested;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Requested = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_Requested) */

void zx_hrxml_RankedResult_ADD_Requested(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Requested->g;
    x->Requested = z;
    return;
  case -1:
    y = x->Requested;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Requested; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_Requested) */

void zx_hrxml_RankedResult_DEL_Requested(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Requested = (struct zx_elem_s*)x->Requested->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Requested;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Requested; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_Offered) */

int zx_hrxml_RankedResult_NUM_Offered(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Offered; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_Offered) */

struct zx_elem_s* zx_hrxml_RankedResult_GET_Offered(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Offered; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_Offered) */

struct zx_elem_s* zx_hrxml_RankedResult_POP_Offered(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Offered;
  if (y)
    x->Offered = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_Offered) */

void zx_hrxml_RankedResult_PUSH_Offered(struct zx_hrxml_RankedResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Offered->g;
  x->Offered = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_Offered) */

void zx_hrxml_RankedResult_REV_Offered(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Offered;
  if (!y) return;
  x->Offered = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Offered->g;
    x->Offered = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_Offered) */

void zx_hrxml_RankedResult_PUT_Offered(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Offered;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Offered = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_Offered) */

void zx_hrxml_RankedResult_ADD_Offered(struct zx_hrxml_RankedResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Offered->g;
    x->Offered = z;
    return;
  case -1:
    y = x->Offered;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Offered; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_Offered) */

void zx_hrxml_RankedResult_DEL_Offered(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Offered = (struct zx_elem_s*)x->Offered->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Offered;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Offered; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_Score) */

int zx_hrxml_RankedResult_NUM_Score(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Score_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Score; y; ++n, y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_Score) */

struct zx_hrxml_Score_s* zx_hrxml_RankedResult_GET_Score(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_Score_s* y;
  if (!x) return 0;
  for (y = x->Score; n>=0 && y; --n, y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_Score) */

struct zx_hrxml_Score_s* zx_hrxml_RankedResult_POP_Score(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Score_s* y;
  if (!x) return 0;
  y = x->Score;
  if (y)
    x->Score = (struct zx_hrxml_Score_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_Score) */

void zx_hrxml_RankedResult_PUSH_Score(struct zx_hrxml_RankedResult_s* x, struct zx_hrxml_Score_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Score->gg.g;
  x->Score = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_Score) */

void zx_hrxml_RankedResult_REV_Score(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Score_s* nxt;
  struct zx_hrxml_Score_s* y;
  if (!x) return;
  y = x->Score;
  if (!y) return;
  x->Score = 0;
  while (y) {
    nxt = (struct zx_hrxml_Score_s*)y->gg.g.n;
    y->gg.g.n = &x->Score->gg.g;
    x->Score = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_Score) */

void zx_hrxml_RankedResult_PUT_Score(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_Score_s* z)
{
  struct zx_hrxml_Score_s* y;
  if (!x || !z) return;
  y = x->Score;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Score = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_Score) */

void zx_hrxml_RankedResult_ADD_Score(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_Score_s* z)
{
  struct zx_hrxml_Score_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Score->gg.g;
    x->Score = z;
    return;
  case -1:
    y = x->Score;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Score; n > 1 && y; --n, y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_Score) */

void zx_hrxml_RankedResult_DEL_Score(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_Score_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Score = (struct zx_hrxml_Score_s*)x->Score->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Score_s*)x->Score;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Score; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Score_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_Weight) */

int zx_hrxml_RankedResult_NUM_Weight(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Weight_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Weight; y; ++n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_RankedResult_GET_Weight(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  for (y = x->Weight; n>=0 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_RankedResult_POP_Weight(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  y = x->Weight;
  if (y)
    x->Weight = (struct zx_hrxml_Weight_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_Weight) */

void zx_hrxml_RankedResult_PUSH_Weight(struct zx_hrxml_RankedResult_s* x, struct zx_hrxml_Weight_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Weight->gg.g;
  x->Weight = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_Weight) */

void zx_hrxml_RankedResult_REV_Weight(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_Weight_s* nxt;
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  y = x->Weight;
  if (!y) return;
  x->Weight = 0;
  while (y) {
    nxt = (struct zx_hrxml_Weight_s*)y->gg.g.n;
    y->gg.g.n = &x->Weight->gg.g;
    x->Weight = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_Weight) */

void zx_hrxml_RankedResult_PUT_Weight(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  y = x->Weight;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Weight = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_Weight) */

void zx_hrxml_RankedResult_ADD_Weight(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Weight->gg.g;
    x->Weight = z;
    return;
  case -1:
    y = x->Weight;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_Weight) */

void zx_hrxml_RankedResult_DEL_Weight(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Weight = (struct zx_hrxml_Weight_s*)x->Weight->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Weight_s*)x->Weight;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_UserArea) */

int zx_hrxml_RankedResult_NUM_UserArea(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RankedResult_GET_UserArea(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RankedResult_POP_UserArea(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_UserArea) */

void zx_hrxml_RankedResult_PUSH_UserArea(struct zx_hrxml_RankedResult_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_UserArea) */

void zx_hrxml_RankedResult_REV_UserArea(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_UserArea) */

void zx_hrxml_RankedResult_PUT_UserArea(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_UserArea) */

void zx_hrxml_RankedResult_ADD_UserArea(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_UserArea) */

void zx_hrxml_RankedResult_DEL_UserArea(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedResult_NUM_RankedResult) */

int zx_hrxml_RankedResult_NUM_RankedResult(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_RankedResult_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RankedResult; y; ++n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedResult_GET_RankedResult) */

struct zx_hrxml_RankedResult_s* zx_hrxml_RankedResult_GET_RankedResult(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return 0;
  for (y = x->RankedResult; n>=0 && y; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_POP_RankedResult) */

struct zx_hrxml_RankedResult_s* zx_hrxml_RankedResult_POP_RankedResult(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return 0;
  y = x->RankedResult;
  if (y)
    x->RankedResult = (struct zx_hrxml_RankedResult_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedResult_PUSH_RankedResult) */

void zx_hrxml_RankedResult_PUSH_RankedResult(struct zx_hrxml_RankedResult_s* x, struct zx_hrxml_RankedResult_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RankedResult->gg.g;
  x->RankedResult = z;
}

/* FUNC(zx_hrxml_RankedResult_REV_RankedResult) */

void zx_hrxml_RankedResult_REV_RankedResult(struct zx_hrxml_RankedResult_s* x)
{
  struct zx_hrxml_RankedResult_s* nxt;
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return;
  y = x->RankedResult;
  if (!y) return;
  x->RankedResult = 0;
  while (y) {
    nxt = (struct zx_hrxml_RankedResult_s*)y->gg.g.n;
    y->gg.g.n = &x->RankedResult->gg.g;
    x->RankedResult = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedResult_PUT_RankedResult) */

void zx_hrxml_RankedResult_PUT_RankedResult(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_RankedResult_s* z)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x || !z) return;
  y = x->RankedResult;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RankedResult = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RankedResult_ADD_RankedResult) */

void zx_hrxml_RankedResult_ADD_RankedResult(struct zx_hrxml_RankedResult_s* x, int n, struct zx_hrxml_RankedResult_s* z)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RankedResult->gg.g;
    x->RankedResult = z;
    return;
  case -1:
    y = x->RankedResult;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedResult; n > 1 && y; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RankedResult_DEL_RankedResult) */

void zx_hrxml_RankedResult_DEL_RankedResult(struct zx_hrxml_RankedResult_s* x, int n)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RankedResult = (struct zx_hrxml_RankedResult_s*)x->RankedResult->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RankedResult_s*)x->RankedResult;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedResult; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RankedSearchResults_NUM_RankedResult) */

int zx_hrxml_RankedSearchResults_NUM_RankedResult(struct zx_hrxml_RankedSearchResults_s* x)
{
  struct zx_hrxml_RankedResult_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RankedResult; y; ++n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RankedSearchResults_GET_RankedResult) */

struct zx_hrxml_RankedResult_s* zx_hrxml_RankedSearchResults_GET_RankedResult(struct zx_hrxml_RankedSearchResults_s* x, int n)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return 0;
  for (y = x->RankedResult; n>=0 && y; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RankedSearchResults_POP_RankedResult) */

struct zx_hrxml_RankedResult_s* zx_hrxml_RankedSearchResults_POP_RankedResult(struct zx_hrxml_RankedSearchResults_s* x)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return 0;
  y = x->RankedResult;
  if (y)
    x->RankedResult = (struct zx_hrxml_RankedResult_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RankedSearchResults_PUSH_RankedResult) */

void zx_hrxml_RankedSearchResults_PUSH_RankedResult(struct zx_hrxml_RankedSearchResults_s* x, struct zx_hrxml_RankedResult_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RankedResult->gg.g;
  x->RankedResult = z;
}

/* FUNC(zx_hrxml_RankedSearchResults_REV_RankedResult) */

void zx_hrxml_RankedSearchResults_REV_RankedResult(struct zx_hrxml_RankedSearchResults_s* x)
{
  struct zx_hrxml_RankedResult_s* nxt;
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return;
  y = x->RankedResult;
  if (!y) return;
  x->RankedResult = 0;
  while (y) {
    nxt = (struct zx_hrxml_RankedResult_s*)y->gg.g.n;
    y->gg.g.n = &x->RankedResult->gg.g;
    x->RankedResult = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RankedSearchResults_PUT_RankedResult) */

void zx_hrxml_RankedSearchResults_PUT_RankedResult(struct zx_hrxml_RankedSearchResults_s* x, int n, struct zx_hrxml_RankedResult_s* z)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x || !z) return;
  y = x->RankedResult;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RankedResult = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RankedSearchResults_ADD_RankedResult) */

void zx_hrxml_RankedSearchResults_ADD_RankedResult(struct zx_hrxml_RankedSearchResults_s* x, int n, struct zx_hrxml_RankedResult_s* z)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RankedResult->gg.g;
    x->RankedResult = z;
    return;
  case -1:
    y = x->RankedResult;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedResult; n > 1 && y; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RankedSearchResults_DEL_RankedResult) */

void zx_hrxml_RankedSearchResults_DEL_RankedResult(struct zx_hrxml_RankedSearchResults_s* x, int n)
{
  struct zx_hrxml_RankedResult_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RankedResult = (struct zx_hrxml_RankedResult_s*)x->RankedResult->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RankedResult_s*)x->RankedResult;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedResult; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedResult_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Recipient_NUM_PersonName) */

int zx_hrxml_Recipient_NUM_PersonName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Recipient_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_Recipient_GET_PersonName(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Recipient_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_Recipient_POP_PersonName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Recipient_PUSH_PersonName) */

void zx_hrxml_Recipient_PUSH_PersonName(struct zx_hrxml_Recipient_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_Recipient_REV_PersonName) */

void zx_hrxml_Recipient_REV_PersonName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Recipient_PUT_PersonName) */

void zx_hrxml_Recipient_PUT_PersonName(struct zx_hrxml_Recipient_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Recipient_ADD_PersonName) */

void zx_hrxml_Recipient_ADD_PersonName(struct zx_hrxml_Recipient_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Recipient_DEL_PersonName) */

void zx_hrxml_Recipient_DEL_PersonName(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Recipient_NUM_AdditionalText) */

int zx_hrxml_Recipient_NUM_AdditionalText(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AdditionalText; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Recipient_GET_AdditionalText) */

struct zx_elem_s* zx_hrxml_Recipient_GET_AdditionalText(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AdditionalText; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Recipient_POP_AdditionalText) */

struct zx_elem_s* zx_hrxml_Recipient_POP_AdditionalText(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AdditionalText;
  if (y)
    x->AdditionalText = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Recipient_PUSH_AdditionalText) */

void zx_hrxml_Recipient_PUSH_AdditionalText(struct zx_hrxml_Recipient_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AdditionalText->g;
  x->AdditionalText = z;
}

/* FUNC(zx_hrxml_Recipient_REV_AdditionalText) */

void zx_hrxml_Recipient_REV_AdditionalText(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AdditionalText;
  if (!y) return;
  x->AdditionalText = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AdditionalText->g;
    x->AdditionalText = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Recipient_PUT_AdditionalText) */

void zx_hrxml_Recipient_PUT_AdditionalText(struct zx_hrxml_Recipient_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AdditionalText;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AdditionalText = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Recipient_ADD_AdditionalText) */

void zx_hrxml_Recipient_ADD_AdditionalText(struct zx_hrxml_Recipient_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AdditionalText->g;
    x->AdditionalText = z;
    return;
  case -1:
    y = x->AdditionalText;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AdditionalText; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Recipient_DEL_AdditionalText) */

void zx_hrxml_Recipient_DEL_AdditionalText(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AdditionalText = (struct zx_elem_s*)x->AdditionalText->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AdditionalText;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AdditionalText; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Recipient_NUM_Organization) */

int zx_hrxml_Recipient_NUM_Organization(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_Organization_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Organization; y; ++n, y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Recipient_GET_Organization) */

struct zx_hrxml_Organization_s* zx_hrxml_Recipient_GET_Organization(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_hrxml_Organization_s* y;
  if (!x) return 0;
  for (y = x->Organization; n>=0 && y; --n, y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Recipient_POP_Organization) */

struct zx_hrxml_Organization_s* zx_hrxml_Recipient_POP_Organization(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_Organization_s* y;
  if (!x) return 0;
  y = x->Organization;
  if (y)
    x->Organization = (struct zx_hrxml_Organization_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Recipient_PUSH_Organization) */

void zx_hrxml_Recipient_PUSH_Organization(struct zx_hrxml_Recipient_s* x, struct zx_hrxml_Organization_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Organization->gg.g;
  x->Organization = z;
}

/* FUNC(zx_hrxml_Recipient_REV_Organization) */

void zx_hrxml_Recipient_REV_Organization(struct zx_hrxml_Recipient_s* x)
{
  struct zx_hrxml_Organization_s* nxt;
  struct zx_hrxml_Organization_s* y;
  if (!x) return;
  y = x->Organization;
  if (!y) return;
  x->Organization = 0;
  while (y) {
    nxt = (struct zx_hrxml_Organization_s*)y->gg.g.n;
    y->gg.g.n = &x->Organization->gg.g;
    x->Organization = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Recipient_PUT_Organization) */

void zx_hrxml_Recipient_PUT_Organization(struct zx_hrxml_Recipient_s* x, int n, struct zx_hrxml_Organization_s* z)
{
  struct zx_hrxml_Organization_s* y;
  if (!x || !z) return;
  y = x->Organization;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Organization = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Recipient_ADD_Organization) */

void zx_hrxml_Recipient_ADD_Organization(struct zx_hrxml_Recipient_s* x, int n, struct zx_hrxml_Organization_s* z)
{
  struct zx_hrxml_Organization_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Organization->gg.g;
    x->Organization = z;
    return;
  case -1:
    y = x->Organization;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Organization; n > 1 && y; --n, y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Recipient_DEL_Organization) */

void zx_hrxml_Recipient_DEL_Organization(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_hrxml_Organization_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Organization = (struct zx_hrxml_Organization_s*)x->Organization->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Organization_s*)x->Organization;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Organization; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Organization_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Recipient_NUM_OrganizationName) */

int zx_hrxml_Recipient_NUM_OrganizationName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Recipient_GET_OrganizationName) */

struct zx_elem_s* zx_hrxml_Recipient_GET_OrganizationName(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrganizationName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Recipient_POP_OrganizationName) */

struct zx_elem_s* zx_hrxml_Recipient_POP_OrganizationName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrganizationName;
  if (y)
    x->OrganizationName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Recipient_PUSH_OrganizationName) */

void zx_hrxml_Recipient_PUSH_OrganizationName(struct zx_hrxml_Recipient_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrganizationName->g;
  x->OrganizationName = z;
}

/* FUNC(zx_hrxml_Recipient_REV_OrganizationName) */

void zx_hrxml_Recipient_REV_OrganizationName(struct zx_hrxml_Recipient_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrganizationName;
  if (!y) return;
  x->OrganizationName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrganizationName->g;
    x->OrganizationName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Recipient_PUT_OrganizationName) */

void zx_hrxml_Recipient_PUT_OrganizationName(struct zx_hrxml_Recipient_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrganizationName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrganizationName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Recipient_ADD_OrganizationName) */

void zx_hrxml_Recipient_ADD_OrganizationName(struct zx_hrxml_Recipient_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrganizationName->g;
    x->OrganizationName = z;
    return;
  case -1:
    y = x->OrganizationName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Recipient_DEL_OrganizationName) */

void zx_hrxml_Recipient_DEL_OrganizationName(struct zx_hrxml_Recipient_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationName = (struct zx_elem_s*)x->OrganizationName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrganizationName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Reference_NUM_PersonName) */

int zx_hrxml_Reference_NUM_PersonName(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonName; y; ++n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Reference_GET_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_Reference_GET_PersonName(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  for (y = x->PersonName; n>=0 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Reference_POP_PersonName) */

struct zx_hrxml_PersonName_s* zx_hrxml_Reference_POP_PersonName(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return 0;
  y = x->PersonName;
  if (y)
    x->PersonName = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Reference_PUSH_PersonName) */

void zx_hrxml_Reference_PUSH_PersonName(struct zx_hrxml_Reference_s* x, struct zx_hrxml_PersonName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonName->gg.g;
  x->PersonName = z;
}

/* FUNC(zx_hrxml_Reference_REV_PersonName) */

void zx_hrxml_Reference_REV_PersonName(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_PersonName_s* nxt;
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  y = x->PersonName;
  if (!y) return;
  x->PersonName = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonName_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Reference_PUT_PersonName) */

void zx_hrxml_Reference_PUT_PersonName(struct zx_hrxml_Reference_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  y = x->PersonName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Reference_ADD_PersonName) */

void zx_hrxml_Reference_ADD_PersonName(struct zx_hrxml_Reference_s* x, int n, struct zx_hrxml_PersonName_s* z)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonName->gg.g;
    x->PersonName = z;
    return;
  case -1:
    y = x->PersonName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Reference_DEL_PersonName) */

void zx_hrxml_Reference_DEL_PersonName(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_hrxml_PersonName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonName = (struct zx_hrxml_PersonName_s*)x->PersonName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonName_s*)x->PersonName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Reference_NUM_PositionTitle) */

int zx_hrxml_Reference_NUM_PositionTitle(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionTitle; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Reference_GET_PositionTitle) */

struct zx_elem_s* zx_hrxml_Reference_GET_PositionTitle(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PositionTitle; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Reference_POP_PositionTitle) */

struct zx_elem_s* zx_hrxml_Reference_POP_PositionTitle(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PositionTitle;
  if (y)
    x->PositionTitle = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Reference_PUSH_PositionTitle) */

void zx_hrxml_Reference_PUSH_PositionTitle(struct zx_hrxml_Reference_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PositionTitle->g;
  x->PositionTitle = z;
}

/* FUNC(zx_hrxml_Reference_REV_PositionTitle) */

void zx_hrxml_Reference_REV_PositionTitle(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PositionTitle;
  if (!y) return;
  x->PositionTitle = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PositionTitle->g;
    x->PositionTitle = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Reference_PUT_PositionTitle) */

void zx_hrxml_Reference_PUT_PositionTitle(struct zx_hrxml_Reference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PositionTitle;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PositionTitle = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Reference_ADD_PositionTitle) */

void zx_hrxml_Reference_ADD_PositionTitle(struct zx_hrxml_Reference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PositionTitle->g;
    x->PositionTitle = z;
    return;
  case -1:
    y = x->PositionTitle;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Reference_DEL_PositionTitle) */

void zx_hrxml_Reference_DEL_PositionTitle(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionTitle = (struct zx_elem_s*)x->PositionTitle->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PositionTitle;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PositionTitle; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Reference_NUM_ContactMethod) */

int zx_hrxml_Reference_NUM_ContactMethod(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactMethod; y; ++n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Reference_GET_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_Reference_GET_ContactMethod(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  for (y = x->ContactMethod; n>=0 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Reference_POP_ContactMethod) */

struct zx_hrxml_ContactMethod_s* zx_hrxml_Reference_POP_ContactMethod(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return 0;
  y = x->ContactMethod;
  if (y)
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Reference_PUSH_ContactMethod) */

void zx_hrxml_Reference_PUSH_ContactMethod(struct zx_hrxml_Reference_s* x, struct zx_hrxml_ContactMethod_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactMethod->gg.g;
  x->ContactMethod = z;
}

/* FUNC(zx_hrxml_Reference_REV_ContactMethod) */

void zx_hrxml_Reference_REV_ContactMethod(struct zx_hrxml_Reference_s* x)
{
  struct zx_hrxml_ContactMethod_s* nxt;
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  y = x->ContactMethod;
  if (!y) return;
  x->ContactMethod = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Reference_PUT_ContactMethod) */

void zx_hrxml_Reference_PUT_ContactMethod(struct zx_hrxml_Reference_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  y = x->ContactMethod;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactMethod = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Reference_ADD_ContactMethod) */

void zx_hrxml_Reference_ADD_ContactMethod(struct zx_hrxml_Reference_s* x, int n, struct zx_hrxml_ContactMethod_s* z)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactMethod->gg.g;
    x->ContactMethod = z;
    return;
  case -1:
    y = x->ContactMethod;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Reference_DEL_ContactMethod) */

void zx_hrxml_Reference_DEL_ContactMethod(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_hrxml_ContactMethod_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactMethod = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactMethod_s*)x->ContactMethod;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactMethod; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactMethod_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Reference_NUM_Comments) */

int zx_hrxml_Reference_NUM_Comments(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Reference_GET_Comments) */

struct zx_elem_s* zx_hrxml_Reference_GET_Comments(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Reference_POP_Comments) */

struct zx_elem_s* zx_hrxml_Reference_POP_Comments(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Reference_PUSH_Comments) */

void zx_hrxml_Reference_PUSH_Comments(struct zx_hrxml_Reference_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Reference_REV_Comments) */

void zx_hrxml_Reference_REV_Comments(struct zx_hrxml_Reference_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Reference_PUT_Comments) */

void zx_hrxml_Reference_PUT_Comments(struct zx_hrxml_Reference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Reference_ADD_Comments) */

void zx_hrxml_Reference_ADD_Comments(struct zx_hrxml_Reference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Reference_DEL_Comments) */

void zx_hrxml_Reference_DEL_Comments(struct zx_hrxml_Reference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Reference_GET_type) */
struct zx_str* zx_hrxml_Reference_GET_type(struct zx_hrxml_Reference_s* x) { return x->type; }
/* FUNC(zx_hrxml_Reference_PUT_type) */
void zx_hrxml_Reference_PUT_type(struct zx_hrxml_Reference_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_References_NUM_Reference) */

int zx_hrxml_References_NUM_Reference(struct zx_hrxml_References_s* x)
{
  struct zx_hrxml_Reference_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Reference; y; ++n, y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_References_GET_Reference) */

struct zx_hrxml_Reference_s* zx_hrxml_References_GET_Reference(struct zx_hrxml_References_s* x, int n)
{
  struct zx_hrxml_Reference_s* y;
  if (!x) return 0;
  for (y = x->Reference; n>=0 && y; --n, y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_References_POP_Reference) */

struct zx_hrxml_Reference_s* zx_hrxml_References_POP_Reference(struct zx_hrxml_References_s* x)
{
  struct zx_hrxml_Reference_s* y;
  if (!x) return 0;
  y = x->Reference;
  if (y)
    x->Reference = (struct zx_hrxml_Reference_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_References_PUSH_Reference) */

void zx_hrxml_References_PUSH_Reference(struct zx_hrxml_References_s* x, struct zx_hrxml_Reference_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Reference->gg.g;
  x->Reference = z;
}

/* FUNC(zx_hrxml_References_REV_Reference) */

void zx_hrxml_References_REV_Reference(struct zx_hrxml_References_s* x)
{
  struct zx_hrxml_Reference_s* nxt;
  struct zx_hrxml_Reference_s* y;
  if (!x) return;
  y = x->Reference;
  if (!y) return;
  x->Reference = 0;
  while (y) {
    nxt = (struct zx_hrxml_Reference_s*)y->gg.g.n;
    y->gg.g.n = &x->Reference->gg.g;
    x->Reference = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_References_PUT_Reference) */

void zx_hrxml_References_PUT_Reference(struct zx_hrxml_References_s* x, int n, struct zx_hrxml_Reference_s* z)
{
  struct zx_hrxml_Reference_s* y;
  if (!x || !z) return;
  y = x->Reference;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Reference = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_References_ADD_Reference) */

void zx_hrxml_References_ADD_Reference(struct zx_hrxml_References_s* x, int n, struct zx_hrxml_Reference_s* z)
{
  struct zx_hrxml_Reference_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Reference->gg.g;
    x->Reference = z;
    return;
  case -1:
    y = x->Reference;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Reference; n > 1 && y; --n, y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_References_DEL_Reference) */

void zx_hrxml_References_DEL_Reference(struct zx_hrxml_References_s* x, int n)
{
  struct zx_hrxml_Reference_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Reference = (struct zx_hrxml_Reference_s*)x->Reference->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Reference_s*)x->Reference;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Reference; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Reference_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_OrganizationName) */

int zx_hrxml_RelatedOrganization_NUM_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_OrganizationName) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_GET_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrganizationName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_OrganizationName) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_POP_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrganizationName;
  if (y)
    x->OrganizationName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_OrganizationName) */

void zx_hrxml_RelatedOrganization_PUSH_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrganizationName->g;
  x->OrganizationName = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_OrganizationName) */

void zx_hrxml_RelatedOrganization_REV_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrganizationName;
  if (!y) return;
  x->OrganizationName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrganizationName->g;
    x->OrganizationName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_OrganizationName) */

void zx_hrxml_RelatedOrganization_PUT_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrganizationName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrganizationName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_OrganizationName) */

void zx_hrxml_RelatedOrganization_ADD_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrganizationName->g;
    x->OrganizationName = z;
    return;
  case -1:
    y = x->OrganizationName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_OrganizationName) */

void zx_hrxml_RelatedOrganization_DEL_OrganizationName(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationName = (struct zx_elem_s*)x->OrganizationName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrganizationName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_OrganizationId) */

int zx_hrxml_RelatedOrganization_NUM_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationId; y; ++n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_RelatedOrganization_GET_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  for (y = x->OrganizationId; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_RelatedOrganization_POP_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  y = x->OrganizationId;
  if (y)
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_OrganizationId) */

void zx_hrxml_RelatedOrganization_PUSH_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_OrganizationId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationId->gg.g;
  x->OrganizationId = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_OrganizationId) */

void zx_hrxml_RelatedOrganization_REV_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationId_s* nxt;
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  y = x->OrganizationId;
  if (!y) return;
  x->OrganizationId = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_OrganizationId) */

void zx_hrxml_RelatedOrganization_PUT_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  y = x->OrganizationId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_OrganizationId) */

void zx_hrxml_RelatedOrganization_ADD_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = z;
    return;
  case -1:
    y = x->OrganizationId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_OrganizationId) */

void zx_hrxml_RelatedOrganization_DEL_OrganizationId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_TaxId) */

int zx_hrxml_RelatedOrganization_NUM_TaxId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_TaxId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TaxId; y; ++n, y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_TaxId) */

struct zx_hrxml_TaxId_s* zx_hrxml_RelatedOrganization_GET_TaxId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_TaxId_s* y;
  if (!x) return 0;
  for (y = x->TaxId; n>=0 && y; --n, y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_TaxId) */

struct zx_hrxml_TaxId_s* zx_hrxml_RelatedOrganization_POP_TaxId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_TaxId_s* y;
  if (!x) return 0;
  y = x->TaxId;
  if (y)
    x->TaxId = (struct zx_hrxml_TaxId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_TaxId) */

void zx_hrxml_RelatedOrganization_PUSH_TaxId(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_TaxId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TaxId->gg.g;
  x->TaxId = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_TaxId) */

void zx_hrxml_RelatedOrganization_REV_TaxId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_TaxId_s* nxt;
  struct zx_hrxml_TaxId_s* y;
  if (!x) return;
  y = x->TaxId;
  if (!y) return;
  x->TaxId = 0;
  while (y) {
    nxt = (struct zx_hrxml_TaxId_s*)y->gg.g.n;
    y->gg.g.n = &x->TaxId->gg.g;
    x->TaxId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_TaxId) */

void zx_hrxml_RelatedOrganization_PUT_TaxId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_TaxId_s* z)
{
  struct zx_hrxml_TaxId_s* y;
  if (!x || !z) return;
  y = x->TaxId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TaxId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_TaxId) */

void zx_hrxml_RelatedOrganization_ADD_TaxId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_TaxId_s* z)
{
  struct zx_hrxml_TaxId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TaxId->gg.g;
    x->TaxId = z;
    return;
  case -1:
    y = x->TaxId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxId; n > 1 && y; --n, y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_TaxId) */

void zx_hrxml_RelatedOrganization_DEL_TaxId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_TaxId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TaxId = (struct zx_hrxml_TaxId_s*)x->TaxId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TaxId_s*)x->TaxId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TaxId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TaxId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_LegalId) */

int zx_hrxml_RelatedOrganization_NUM_LegalId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalId; y; ++n, y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_LegalId) */

struct zx_hrxml_LegalId_s* zx_hrxml_RelatedOrganization_GET_LegalId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_LegalId_s* y;
  if (!x) return 0;
  for (y = x->LegalId; n>=0 && y; --n, y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_LegalId) */

struct zx_hrxml_LegalId_s* zx_hrxml_RelatedOrganization_POP_LegalId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalId_s* y;
  if (!x) return 0;
  y = x->LegalId;
  if (y)
    x->LegalId = (struct zx_hrxml_LegalId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_LegalId) */

void zx_hrxml_RelatedOrganization_PUSH_LegalId(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_LegalId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LegalId->gg.g;
  x->LegalId = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_LegalId) */

void zx_hrxml_RelatedOrganization_REV_LegalId(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalId_s* nxt;
  struct zx_hrxml_LegalId_s* y;
  if (!x) return;
  y = x->LegalId;
  if (!y) return;
  x->LegalId = 0;
  while (y) {
    nxt = (struct zx_hrxml_LegalId_s*)y->gg.g.n;
    y->gg.g.n = &x->LegalId->gg.g;
    x->LegalId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_LegalId) */

void zx_hrxml_RelatedOrganization_PUT_LegalId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_LegalId_s* z)
{
  struct zx_hrxml_LegalId_s* y;
  if (!x || !z) return;
  y = x->LegalId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LegalId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_LegalId) */

void zx_hrxml_RelatedOrganization_ADD_LegalId(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_LegalId_s* z)
{
  struct zx_hrxml_LegalId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LegalId->gg.g;
    x->LegalId = z;
    return;
  case -1:
    y = x->LegalId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalId; n > 1 && y; --n, y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_LegalId) */

void zx_hrxml_RelatedOrganization_DEL_LegalId(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_LegalId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalId = (struct zx_hrxml_LegalId_s*)x->LegalId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LegalId_s*)x->LegalId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_DunsNumber) */

int zx_hrxml_RelatedOrganization_NUM_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DunsNumber_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DunsNumber; y; ++n, y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_DunsNumber) */

struct zx_hrxml_DunsNumber_s* zx_hrxml_RelatedOrganization_GET_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_DunsNumber_s* y;
  if (!x) return 0;
  for (y = x->DunsNumber; n>=0 && y; --n, y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_DunsNumber) */

struct zx_hrxml_DunsNumber_s* zx_hrxml_RelatedOrganization_POP_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DunsNumber_s* y;
  if (!x) return 0;
  y = x->DunsNumber;
  if (y)
    x->DunsNumber = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_DunsNumber) */

void zx_hrxml_RelatedOrganization_PUSH_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_DunsNumber_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DunsNumber->gg.g;
  x->DunsNumber = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_DunsNumber) */

void zx_hrxml_RelatedOrganization_REV_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DunsNumber_s* nxt;
  struct zx_hrxml_DunsNumber_s* y;
  if (!x) return;
  y = x->DunsNumber;
  if (!y) return;
  x->DunsNumber = 0;
  while (y) {
    nxt = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n;
    y->gg.g.n = &x->DunsNumber->gg.g;
    x->DunsNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_DunsNumber) */

void zx_hrxml_RelatedOrganization_PUT_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_DunsNumber_s* z)
{
  struct zx_hrxml_DunsNumber_s* y;
  if (!x || !z) return;
  y = x->DunsNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DunsNumber = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_DunsNumber) */

void zx_hrxml_RelatedOrganization_ADD_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_DunsNumber_s* z)
{
  struct zx_hrxml_DunsNumber_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DunsNumber->gg.g;
    x->DunsNumber = z;
    return;
  case -1:
    y = x->DunsNumber;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DunsNumber; n > 1 && y; --n, y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_DunsNumber) */

void zx_hrxml_RelatedOrganization_DEL_DunsNumber(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_DunsNumber_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DunsNumber = (struct zx_hrxml_DunsNumber_s*)x->DunsNumber->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DunsNumber_s*)x->DunsNumber;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DunsNumber; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DunsNumber_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_IsPublicCompany) */

int zx_hrxml_RelatedOrganization_NUM_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IsPublicCompany; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_IsPublicCompany) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_GET_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->IsPublicCompany; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_IsPublicCompany) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_POP_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->IsPublicCompany;
  if (y)
    x->IsPublicCompany = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_IsPublicCompany) */

void zx_hrxml_RelatedOrganization_PUSH_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->IsPublicCompany->g;
  x->IsPublicCompany = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_IsPublicCompany) */

void zx_hrxml_RelatedOrganization_REV_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->IsPublicCompany;
  if (!y) return;
  x->IsPublicCompany = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->IsPublicCompany->g;
    x->IsPublicCompany = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_IsPublicCompany) */

void zx_hrxml_RelatedOrganization_PUT_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->IsPublicCompany;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->IsPublicCompany = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_IsPublicCompany) */

void zx_hrxml_RelatedOrganization_ADD_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->IsPublicCompany->g;
    x->IsPublicCompany = z;
    return;
  case -1:
    y = x->IsPublicCompany;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IsPublicCompany; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_IsPublicCompany) */

void zx_hrxml_RelatedOrganization_DEL_IsPublicCompany(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IsPublicCompany = (struct zx_elem_s*)x->IsPublicCompany->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->IsPublicCompany;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->IsPublicCompany; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_Stock) */

int zx_hrxml_RelatedOrganization_NUM_Stock(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Stock_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Stock; y; ++n, y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_Stock) */

struct zx_hrxml_Stock_s* zx_hrxml_RelatedOrganization_GET_Stock(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_Stock_s* y;
  if (!x) return 0;
  for (y = x->Stock; n>=0 && y; --n, y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_Stock) */

struct zx_hrxml_Stock_s* zx_hrxml_RelatedOrganization_POP_Stock(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Stock_s* y;
  if (!x) return 0;
  y = x->Stock;
  if (y)
    x->Stock = (struct zx_hrxml_Stock_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_Stock) */

void zx_hrxml_RelatedOrganization_PUSH_Stock(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_Stock_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Stock->gg.g;
  x->Stock = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_Stock) */

void zx_hrxml_RelatedOrganization_REV_Stock(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Stock_s* nxt;
  struct zx_hrxml_Stock_s* y;
  if (!x) return;
  y = x->Stock;
  if (!y) return;
  x->Stock = 0;
  while (y) {
    nxt = (struct zx_hrxml_Stock_s*)y->gg.g.n;
    y->gg.g.n = &x->Stock->gg.g;
    x->Stock = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_Stock) */

void zx_hrxml_RelatedOrganization_PUT_Stock(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_Stock_s* z)
{
  struct zx_hrxml_Stock_s* y;
  if (!x || !z) return;
  y = x->Stock;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Stock = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_Stock) */

void zx_hrxml_RelatedOrganization_ADD_Stock(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_Stock_s* z)
{
  struct zx_hrxml_Stock_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Stock->gg.g;
    x->Stock = z;
    return;
  case -1:
    y = x->Stock;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Stock; n > 1 && y; --n, y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_Stock) */

void zx_hrxml_RelatedOrganization_DEL_Stock(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_Stock_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Stock = (struct zx_hrxml_Stock_s*)x->Stock->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Stock_s*)x->Stock;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Stock; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Stock_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_MissionStatement) */

int zx_hrxml_RelatedOrganization_NUM_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MissionStatement; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_MissionStatement) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_GET_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MissionStatement; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_MissionStatement) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_POP_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MissionStatement;
  if (y)
    x->MissionStatement = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_MissionStatement) */

void zx_hrxml_RelatedOrganization_PUSH_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MissionStatement->g;
  x->MissionStatement = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_MissionStatement) */

void zx_hrxml_RelatedOrganization_REV_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MissionStatement;
  if (!y) return;
  x->MissionStatement = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MissionStatement->g;
    x->MissionStatement = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_MissionStatement) */

void zx_hrxml_RelatedOrganization_PUT_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MissionStatement;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MissionStatement = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_MissionStatement) */

void zx_hrxml_RelatedOrganization_ADD_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MissionStatement->g;
    x->MissionStatement = z;
    return;
  case -1:
    y = x->MissionStatement;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MissionStatement; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_MissionStatement) */

void zx_hrxml_RelatedOrganization_DEL_MissionStatement(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MissionStatement = (struct zx_elem_s*)x->MissionStatement->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MissionStatement;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MissionStatement; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_ValueStatement) */

int zx_hrxml_RelatedOrganization_NUM_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ValueStatement; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_ValueStatement) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_GET_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ValueStatement; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_ValueStatement) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_POP_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ValueStatement;
  if (y)
    x->ValueStatement = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_ValueStatement) */

void zx_hrxml_RelatedOrganization_PUSH_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ValueStatement->g;
  x->ValueStatement = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_ValueStatement) */

void zx_hrxml_RelatedOrganization_REV_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ValueStatement;
  if (!y) return;
  x->ValueStatement = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ValueStatement->g;
    x->ValueStatement = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_ValueStatement) */

void zx_hrxml_RelatedOrganization_PUT_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ValueStatement;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ValueStatement = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_ValueStatement) */

void zx_hrxml_RelatedOrganization_ADD_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ValueStatement->g;
    x->ValueStatement = z;
    return;
  case -1:
    y = x->ValueStatement;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ValueStatement; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_ValueStatement) */

void zx_hrxml_RelatedOrganization_DEL_ValueStatement(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ValueStatement = (struct zx_elem_s*)x->ValueStatement->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ValueStatement;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ValueStatement; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_InternetDomainName) */

int zx_hrxml_RelatedOrganization_NUM_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InternetDomainName; y; ++n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_RelatedOrganization_GET_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  for (y = x->InternetDomainName; n>=0 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_RelatedOrganization_POP_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  y = x->InternetDomainName;
  if (y)
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_InternetDomainName) */

void zx_hrxml_RelatedOrganization_PUSH_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_InternetDomainName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->InternetDomainName->gg.g;
  x->InternetDomainName = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_InternetDomainName) */

void zx_hrxml_RelatedOrganization_REV_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_InternetDomainName_s* nxt;
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  y = x->InternetDomainName;
  if (!y) return;
  x->InternetDomainName = 0;
  while (y) {
    nxt = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
    y->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_InternetDomainName) */

void zx_hrxml_RelatedOrganization_PUT_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  y = x->InternetDomainName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->InternetDomainName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_InternetDomainName) */

void zx_hrxml_RelatedOrganization_ADD_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = z;
    return;
  case -1:
    y = x->InternetDomainName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_InternetDomainName) */

void zx_hrxml_RelatedOrganization_DEL_InternetDomainName(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_DoingBusinessAs) */

int zx_hrxml_RelatedOrganization_NUM_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DoingBusinessAs; y; ++n, y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_DoingBusinessAs) */

struct zx_hrxml_DoingBusinessAs_s* zx_hrxml_RelatedOrganization_GET_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x) return 0;
  for (y = x->DoingBusinessAs; n>=0 && y; --n, y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_DoingBusinessAs) */

struct zx_hrxml_DoingBusinessAs_s* zx_hrxml_RelatedOrganization_POP_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x) return 0;
  y = x->DoingBusinessAs;
  if (y)
    x->DoingBusinessAs = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_DoingBusinessAs) */

void zx_hrxml_RelatedOrganization_PUSH_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_DoingBusinessAs_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DoingBusinessAs->gg.g;
  x->DoingBusinessAs = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_DoingBusinessAs) */

void zx_hrxml_RelatedOrganization_REV_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_DoingBusinessAs_s* nxt;
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x) return;
  y = x->DoingBusinessAs;
  if (!y) return;
  x->DoingBusinessAs = 0;
  while (y) {
    nxt = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n;
    y->gg.g.n = &x->DoingBusinessAs->gg.g;
    x->DoingBusinessAs = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_DoingBusinessAs) */

void zx_hrxml_RelatedOrganization_PUT_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_DoingBusinessAs_s* z)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x || !z) return;
  y = x->DoingBusinessAs;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DoingBusinessAs = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_DoingBusinessAs) */

void zx_hrxml_RelatedOrganization_ADD_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_DoingBusinessAs_s* z)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DoingBusinessAs->gg.g;
    x->DoingBusinessAs = z;
    return;
  case -1:
    y = x->DoingBusinessAs;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DoingBusinessAs; n > 1 && y; --n, y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_DoingBusinessAs) */

void zx_hrxml_RelatedOrganization_DEL_DoingBusinessAs(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_DoingBusinessAs_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DoingBusinessAs = (struct zx_hrxml_DoingBusinessAs_s*)x->DoingBusinessAs->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DoingBusinessAs_s*)x->DoingBusinessAs;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DoingBusinessAs; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DoingBusinessAs_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_LegalClassification) */

int zx_hrxml_RelatedOrganization_NUM_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalClassification_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LegalClassification; y; ++n, y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_LegalClassification) */

struct zx_hrxml_LegalClassification_s* zx_hrxml_RelatedOrganization_GET_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_LegalClassification_s* y;
  if (!x) return 0;
  for (y = x->LegalClassification; n>=0 && y; --n, y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_LegalClassification) */

struct zx_hrxml_LegalClassification_s* zx_hrxml_RelatedOrganization_POP_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalClassification_s* y;
  if (!x) return 0;
  y = x->LegalClassification;
  if (y)
    x->LegalClassification = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_LegalClassification) */

void zx_hrxml_RelatedOrganization_PUSH_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_LegalClassification_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LegalClassification->gg.g;
  x->LegalClassification = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_LegalClassification) */

void zx_hrxml_RelatedOrganization_REV_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_LegalClassification_s* nxt;
  struct zx_hrxml_LegalClassification_s* y;
  if (!x) return;
  y = x->LegalClassification;
  if (!y) return;
  x->LegalClassification = 0;
  while (y) {
    nxt = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n;
    y->gg.g.n = &x->LegalClassification->gg.g;
    x->LegalClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_LegalClassification) */

void zx_hrxml_RelatedOrganization_PUT_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_LegalClassification_s* z)
{
  struct zx_hrxml_LegalClassification_s* y;
  if (!x || !z) return;
  y = x->LegalClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LegalClassification = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_LegalClassification) */

void zx_hrxml_RelatedOrganization_ADD_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_LegalClassification_s* z)
{
  struct zx_hrxml_LegalClassification_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LegalClassification->gg.g;
    x->LegalClassification = z;
    return;
  case -1:
    y = x->LegalClassification;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalClassification; n > 1 && y; --n, y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_LegalClassification) */

void zx_hrxml_RelatedOrganization_DEL_LegalClassification(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_LegalClassification_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LegalClassification = (struct zx_hrxml_LegalClassification_s*)x->LegalClassification->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LegalClassification_s*)x->LegalClassification;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LegalClassification; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LegalClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_IndustryCode) */

int zx_hrxml_RelatedOrganization_NUM_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_RelatedOrganization_GET_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_RelatedOrganization_POP_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_IndustryCode) */

void zx_hrxml_RelatedOrganization_PUSH_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_IndustryCode) */

void zx_hrxml_RelatedOrganization_REV_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_IndustryCode) */

void zx_hrxml_RelatedOrganization_PUT_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_IndustryCode) */

void zx_hrxml_RelatedOrganization_ADD_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_IndustryCode) */

void zx_hrxml_RelatedOrganization_DEL_IndustryCode(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_Headcount) */

int zx_hrxml_RelatedOrganization_NUM_Headcount(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Headcount; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_Headcount) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_GET_Headcount(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Headcount; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_Headcount) */

struct zx_elem_s* zx_hrxml_RelatedOrganization_POP_Headcount(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Headcount;
  if (y)
    x->Headcount = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_Headcount) */

void zx_hrxml_RelatedOrganization_PUSH_Headcount(struct zx_hrxml_RelatedOrganization_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Headcount->g;
  x->Headcount = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_Headcount) */

void zx_hrxml_RelatedOrganization_REV_Headcount(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Headcount;
  if (!y) return;
  x->Headcount = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Headcount->g;
    x->Headcount = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_Headcount) */

void zx_hrxml_RelatedOrganization_PUT_Headcount(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Headcount;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Headcount = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_Headcount) */

void zx_hrxml_RelatedOrganization_ADD_Headcount(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Headcount->g;
    x->Headcount = z;
    return;
  case -1:
    y = x->Headcount;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Headcount; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_Headcount) */

void zx_hrxml_RelatedOrganization_DEL_Headcount(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Headcount = (struct zx_elem_s*)x->Headcount->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Headcount;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Headcount; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_Description) */

int zx_hrxml_RelatedOrganization_NUM_Description(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelatedOrganization_GET_Description(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelatedOrganization_POP_Description(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_Description) */

void zx_hrxml_RelatedOrganization_PUSH_Description(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_Description) */

void zx_hrxml_RelatedOrganization_REV_Description(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_Description) */

void zx_hrxml_RelatedOrganization_PUT_Description(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_Description) */

void zx_hrxml_RelatedOrganization_ADD_Description(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_Description) */

void zx_hrxml_RelatedOrganization_DEL_Description(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_WorkSite) */

int zx_hrxml_RelatedOrganization_NUM_WorkSite(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSite; y; ++n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_RelatedOrganization_GET_WorkSite(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  for (y = x->WorkSite; n>=0 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_RelatedOrganization_POP_WorkSite(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  y = x->WorkSite;
  if (y)
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_WorkSite) */

void zx_hrxml_RelatedOrganization_PUSH_WorkSite(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_WorkSite_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSite->gg.g;
  x->WorkSite = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_WorkSite) */

void zx_hrxml_RelatedOrganization_REV_WorkSite(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_WorkSite_s* nxt;
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  y = x->WorkSite;
  if (!y) return;
  x->WorkSite = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_WorkSite) */

void zx_hrxml_RelatedOrganization_PUT_WorkSite(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  y = x->WorkSite;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSite = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_WorkSite) */

void zx_hrxml_RelatedOrganization_ADD_WorkSite(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = z;
    return;
  case -1:
    y = x->WorkSite;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_WorkSite) */

void zx_hrxml_RelatedOrganization_DEL_WorkSite(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)x->WorkSite->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSite_s*)x->WorkSite;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_ContactInfo) */

int zx_hrxml_RelatedOrganization_NUM_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactInfo; y; ++n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_RelatedOrganization_GET_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  for (y = x->ContactInfo; n>=0 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_RelatedOrganization_POP_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  y = x->ContactInfo;
  if (y)
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_ContactInfo) */

void zx_hrxml_RelatedOrganization_PUSH_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_ContactInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactInfo->gg.g;
  x->ContactInfo = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_ContactInfo) */

void zx_hrxml_RelatedOrganization_REV_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_ContactInfo_s* nxt;
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  y = x->ContactInfo;
  if (!y) return;
  x->ContactInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_ContactInfo) */

void zx_hrxml_RelatedOrganization_PUT_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  y = x->ContactInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_ContactInfo) */

void zx_hrxml_RelatedOrganization_ADD_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = z;
    return;
  case -1:
    y = x->ContactInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_ContactInfo) */

void zx_hrxml_RelatedOrganization_DEL_ContactInfo(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_RelatedOrganization) */

int zx_hrxml_RelatedOrganization_NUM_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RelatedOrganization; y; ++n, y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_RelatedOrganization) */

struct zx_hrxml_RelatedOrganization_s* zx_hrxml_RelatedOrganization_GET_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x) return 0;
  for (y = x->RelatedOrganization; n>=0 && y; --n, y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_RelatedOrganization) */

struct zx_hrxml_RelatedOrganization_s* zx_hrxml_RelatedOrganization_POP_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x) return 0;
  y = x->RelatedOrganization;
  if (y)
    x->RelatedOrganization = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_RelatedOrganization) */

void zx_hrxml_RelatedOrganization_PUSH_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_RelatedOrganization_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RelatedOrganization->gg.g;
  x->RelatedOrganization = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_RelatedOrganization) */

void zx_hrxml_RelatedOrganization_REV_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_RelatedOrganization_s* nxt;
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x) return;
  y = x->RelatedOrganization;
  if (!y) return;
  x->RelatedOrganization = 0;
  while (y) {
    nxt = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n;
    y->gg.g.n = &x->RelatedOrganization->gg.g;
    x->RelatedOrganization = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_RelatedOrganization) */

void zx_hrxml_RelatedOrganization_PUT_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_RelatedOrganization_s* z)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x || !z) return;
  y = x->RelatedOrganization;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RelatedOrganization = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_RelatedOrganization) */

void zx_hrxml_RelatedOrganization_ADD_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_RelatedOrganization_s* z)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RelatedOrganization->gg.g;
    x->RelatedOrganization = z;
    return;
  case -1:
    y = x->RelatedOrganization;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganization; n > 1 && y; --n, y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_RelatedOrganization) */

void zx_hrxml_RelatedOrganization_DEL_RelatedOrganization(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_RelatedOrganization_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RelatedOrganization = (struct zx_hrxml_RelatedOrganization_s*)x->RelatedOrganization->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RelatedOrganization_s*)x->RelatedOrganization;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganization; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganization_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_OrganizationalUnit) */

int zx_hrxml_RelatedOrganization_NUM_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationalUnit; y; ++n, y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_OrganizationalUnit) */

struct zx_hrxml_OrganizationalUnit_s* zx_hrxml_RelatedOrganization_GET_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x) return 0;
  for (y = x->OrganizationalUnit; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_OrganizationalUnit) */

struct zx_hrxml_OrganizationalUnit_s* zx_hrxml_RelatedOrganization_POP_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x) return 0;
  y = x->OrganizationalUnit;
  if (y)
    x->OrganizationalUnit = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_OrganizationalUnit) */

void zx_hrxml_RelatedOrganization_PUSH_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_OrganizationalUnit_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationalUnit->gg.g;
  x->OrganizationalUnit = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_OrganizationalUnit) */

void zx_hrxml_RelatedOrganization_REV_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_OrganizationalUnit_s* nxt;
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x) return;
  y = x->OrganizationalUnit;
  if (!y) return;
  x->OrganizationalUnit = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationalUnit->gg.g;
    x->OrganizationalUnit = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_OrganizationalUnit) */

void zx_hrxml_RelatedOrganization_PUT_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_OrganizationalUnit_s* z)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x || !z) return;
  y = x->OrganizationalUnit;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationalUnit = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_OrganizationalUnit) */

void zx_hrxml_RelatedOrganization_ADD_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_OrganizationalUnit_s* z)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationalUnit->gg.g;
    x->OrganizationalUnit = z;
    return;
  case -1:
    y = x->OrganizationalUnit;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnit; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_OrganizationalUnit) */

void zx_hrxml_RelatedOrganization_DEL_OrganizationalUnit(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnit_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationalUnit = (struct zx_hrxml_OrganizationalUnit_s*)x->OrganizationalUnit->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationalUnit_s*)x->OrganizationalUnit;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnit; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganization_NUM_UserArea) */

int zx_hrxml_RelatedOrganization_NUM_UserArea(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganization_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RelatedOrganization_GET_UserArea(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RelatedOrganization_POP_UserArea(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganization_PUSH_UserArea) */

void zx_hrxml_RelatedOrganization_PUSH_UserArea(struct zx_hrxml_RelatedOrganization_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_RelatedOrganization_REV_UserArea) */

void zx_hrxml_RelatedOrganization_REV_UserArea(struct zx_hrxml_RelatedOrganization_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_PUT_UserArea) */

void zx_hrxml_RelatedOrganization_PUT_UserArea(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganization_ADD_UserArea) */

void zx_hrxml_RelatedOrganization_ADD_UserArea(struct zx_hrxml_RelatedOrganization_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganization_DEL_UserArea) */

void zx_hrxml_RelatedOrganization_DEL_UserArea(struct zx_hrxml_RelatedOrganization_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_RelatedOrganization_GET_relationship) */
struct zx_str* zx_hrxml_RelatedOrganization_GET_relationship(struct zx_hrxml_RelatedOrganization_s* x) { return x->relationship; }
/* FUNC(zx_hrxml_RelatedOrganization_PUT_relationship) */
void zx_hrxml_RelatedOrganization_PUT_relationship(struct zx_hrxml_RelatedOrganization_s* x, struct zx_str* y) { x->relationship = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationalUnitName) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationalUnitName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationalUnitName) */

struct zx_elem_s* zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OrganizationalUnitName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationalUnitName) */

struct zx_elem_s* zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OrganizationalUnitName;
  if (y)
    x->OrganizationalUnitName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationalUnitName) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OrganizationalUnitName->g;
  x->OrganizationalUnitName = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationalUnitName) */

void zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OrganizationalUnitName;
  if (!y) return;
  x->OrganizationalUnitName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OrganizationalUnitName->g;
    x->OrganizationalUnitName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationalUnitName) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OrganizationalUnitName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OrganizationalUnitName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationalUnitName) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OrganizationalUnitName->g;
    x->OrganizationalUnitName = z;
    return;
  case -1:
    y = x->OrganizationalUnitName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationalUnitName) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationalUnitName(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationalUnitName = (struct zx_elem_s*)x->OrganizationalUnitName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OrganizationalUnitName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationalUnitId) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationalUnitId; y; ++n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationalUnitId) */

struct zx_hrxml_OrganizationalUnitId_s* zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return 0;
  for (y = x->OrganizationalUnitId; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationalUnitId) */

struct zx_hrxml_OrganizationalUnitId_s* zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return 0;
  y = x->OrganizationalUnitId;
  if (y)
    x->OrganizationalUnitId = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationalUnitId) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationalUnitId->gg.g;
  x->OrganizationalUnitId = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationalUnitId) */

void zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationalUnitId_s* nxt;
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return;
  y = x->OrganizationalUnitId;
  if (!y) return;
  x->OrganizationalUnitId = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationalUnitId->gg.g;
    x->OrganizationalUnitId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationalUnitId) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x || !z) return;
  y = x->OrganizationalUnitId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationalUnitId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationalUnitId) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationalUnitId_s* z)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationalUnitId->gg.g;
    x->OrganizationalUnitId = z;
    return;
  case -1:
    y = x->OrganizationalUnitId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitId; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationalUnitId) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationalUnitId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationalUnitId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationalUnitId = (struct zx_hrxml_OrganizationalUnitId_s*)x->OrganizationalUnitId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationalUnitId_s*)x->OrganizationalUnitId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationalUnitId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationalUnitId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationId) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationId; y; ++n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_RelatedOrganizationalUnit_GET_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  for (y = x->OrganizationId; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationId) */

struct zx_hrxml_OrganizationId_s* zx_hrxml_RelatedOrganizationalUnit_POP_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return 0;
  y = x->OrganizationId;
  if (y)
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationId) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_OrganizationId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationId->gg.g;
  x->OrganizationId = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationId) */

void zx_hrxml_RelatedOrganizationalUnit_REV_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_OrganizationId_s* nxt;
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  y = x->OrganizationId;
  if (!y) return;
  x->OrganizationId = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationId) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  y = x->OrganizationId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationId) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_OrganizationId_s* z)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationId->gg.g;
    x->OrganizationId = z;
    return;
  case -1:
    y = x->OrganizationId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationId) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_OrganizationId(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_OrganizationId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationId = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationId_s*)x->OrganizationId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_Description) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelatedOrganizationalUnit_GET_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelatedOrganizationalUnit_POP_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_Description) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_Description) */

void zx_hrxml_RelatedOrganizationalUnit_REV_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_Description) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_Description) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_Description) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_Description(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_IndustryCode) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IndustryCode; y; ++n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_RelatedOrganizationalUnit_GET_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  for (y = x->IndustryCode; n>=0 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_IndustryCode) */

struct zx_hrxml_IndustryCode_s* zx_hrxml_RelatedOrganizationalUnit_POP_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return 0;
  y = x->IndustryCode;
  if (y)
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_IndustryCode) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_IndustryCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IndustryCode->gg.g;
  x->IndustryCode = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_IndustryCode) */

void zx_hrxml_RelatedOrganizationalUnit_REV_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_IndustryCode_s* nxt;
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  y = x->IndustryCode;
  if (!y) return;
  x->IndustryCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n;
    y->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_IndustryCode) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  y = x->IndustryCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IndustryCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_IndustryCode) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_IndustryCode_s* z)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IndustryCode->gg.g;
    x->IndustryCode = z;
    return;
  case -1:
    y = x->IndustryCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_IndustryCode) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_IndustryCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_IndustryCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IndustryCode = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IndustryCode_s*)x->IndustryCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IndustryCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IndustryCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_AccountingCode) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AccountingCode; y; ++n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_AccountingCode) */

struct zx_hrxml_AccountingCode_s* zx_hrxml_RelatedOrganizationalUnit_GET_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return 0;
  for (y = x->AccountingCode; n>=0 && y; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_AccountingCode) */

struct zx_hrxml_AccountingCode_s* zx_hrxml_RelatedOrganizationalUnit_POP_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return 0;
  y = x->AccountingCode;
  if (y)
    x->AccountingCode = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_AccountingCode) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_AccountingCode_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AccountingCode->gg.g;
  x->AccountingCode = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_AccountingCode) */

void zx_hrxml_RelatedOrganizationalUnit_REV_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_AccountingCode_s* nxt;
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return;
  y = x->AccountingCode;
  if (!y) return;
  x->AccountingCode = 0;
  while (y) {
    nxt = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n;
    y->gg.g.n = &x->AccountingCode->gg.g;
    x->AccountingCode = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_AccountingCode) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_AccountingCode_s* z)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x || !z) return;
  y = x->AccountingCode;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AccountingCode = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_AccountingCode) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_AccountingCode_s* z)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AccountingCode->gg.g;
    x->AccountingCode = z;
    return;
  case -1:
    y = x->AccountingCode;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AccountingCode; n > 1 && y; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_AccountingCode) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_AccountingCode(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_AccountingCode_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AccountingCode = (struct zx_hrxml_AccountingCode_s*)x->AccountingCode->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AccountingCode_s*)x->AccountingCode;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AccountingCode; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AccountingCode_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_WorkSite) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSite; y; ++n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_RelatedOrganizationalUnit_GET_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  for (y = x->WorkSite; n>=0 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_WorkSite) */

struct zx_hrxml_WorkSite_s* zx_hrxml_RelatedOrganizationalUnit_POP_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return 0;
  y = x->WorkSite;
  if (y)
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_WorkSite) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_WorkSite_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSite->gg.g;
  x->WorkSite = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_WorkSite) */

void zx_hrxml_RelatedOrganizationalUnit_REV_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_WorkSite_s* nxt;
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  y = x->WorkSite;
  if (!y) return;
  x->WorkSite = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSite_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_WorkSite) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  y = x->WorkSite;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSite = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_WorkSite) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_WorkSite_s* z)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSite->gg.g;
    x->WorkSite = z;
    return;
  case -1:
    y = x->WorkSite;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_WorkSite) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_WorkSite(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_WorkSite_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSite = (struct zx_hrxml_WorkSite_s*)x->WorkSite->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSite_s*)x->WorkSite;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSite; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSite_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_RelatedOrganizationalUnit) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RelatedOrganizationalUnit; y; ++n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_RelatedOrganizationalUnit) */

struct zx_hrxml_RelatedOrganizationalUnit_s* zx_hrxml_RelatedOrganizationalUnit_GET_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return 0;
  for (y = x->RelatedOrganizationalUnit; n>=0 && y; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_RelatedOrganizationalUnit) */

struct zx_hrxml_RelatedOrganizationalUnit_s* zx_hrxml_RelatedOrganizationalUnit_POP_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return 0;
  y = x->RelatedOrganizationalUnit;
  if (y)
    x->RelatedOrganizationalUnit = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_RelatedOrganizationalUnit) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
  x->RelatedOrganizationalUnit = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_RelatedOrganizationalUnit) */

void zx_hrxml_RelatedOrganizationalUnit_REV_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* nxt;
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return;
  y = x->RelatedOrganizationalUnit;
  if (!y) return;
  x->RelatedOrganizationalUnit = 0;
  while (y) {
    nxt = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n;
    y->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
    x->RelatedOrganizationalUnit = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_RelatedOrganizationalUnit) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x || !z) return;
  y = x->RelatedOrganizationalUnit;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RelatedOrganizationalUnit = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_RelatedOrganizationalUnit) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_RelatedOrganizationalUnit_s* z)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RelatedOrganizationalUnit->gg.g;
    x->RelatedOrganizationalUnit = z;
    return;
  case -1:
    y = x->RelatedOrganizationalUnit;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganizationalUnit; n > 1 && y; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_RelatedOrganizationalUnit) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_RelatedOrganizationalUnit(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_RelatedOrganizationalUnit_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RelatedOrganizationalUnit = (struct zx_hrxml_RelatedOrganizationalUnit_s*)x->RelatedOrganizationalUnit->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)x->RelatedOrganizationalUnit;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RelatedOrganizationalUnit; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RelatedOrganizationalUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_PersonMember) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PersonMember; y; ++n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_PersonMember) */

struct zx_hrxml_PersonMember_s* zx_hrxml_RelatedOrganizationalUnit_GET_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return 0;
  for (y = x->PersonMember; n>=0 && y; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_PersonMember) */

struct zx_hrxml_PersonMember_s* zx_hrxml_RelatedOrganizationalUnit_POP_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return 0;
  y = x->PersonMember;
  if (y)
    x->PersonMember = (struct zx_hrxml_PersonMember_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_PersonMember) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_PersonMember_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PersonMember->gg.g;
  x->PersonMember = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_PersonMember) */

void zx_hrxml_RelatedOrganizationalUnit_REV_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_PersonMember_s* nxt;
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return;
  y = x->PersonMember;
  if (!y) return;
  x->PersonMember = 0;
  while (y) {
    nxt = (struct zx_hrxml_PersonMember_s*)y->gg.g.n;
    y->gg.g.n = &x->PersonMember->gg.g;
    x->PersonMember = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_PersonMember) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_PersonMember_s* z)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x || !z) return;
  y = x->PersonMember;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PersonMember = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_PersonMember) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_PersonMember_s* z)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PersonMember->gg.g;
    x->PersonMember = z;
    return;
  case -1:
    y = x->PersonMember;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonMember; n > 1 && y; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_PersonMember) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_PersonMember(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_PersonMember_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PersonMember = (struct zx_hrxml_PersonMember_s*)x->PersonMember->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PersonMember_s*)x->PersonMember;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PersonMember; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PersonMember_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_NUM_UserArea) */

int zx_hrxml_RelatedOrganizationalUnit_NUM_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RelatedOrganizationalUnit_GET_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RelatedOrganizationalUnit_POP_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUSH_UserArea) */

void zx_hrxml_RelatedOrganizationalUnit_PUSH_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_REV_UserArea) */

void zx_hrxml_RelatedOrganizationalUnit_REV_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_UserArea) */

void zx_hrxml_RelatedOrganizationalUnit_PUT_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_ADD_UserArea) */

void zx_hrxml_RelatedOrganizationalUnit_ADD_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_DEL_UserArea) */

void zx_hrxml_RelatedOrganizationalUnit_DEL_UserArea(struct zx_hrxml_RelatedOrganizationalUnit_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_hierarchicalRole) */
struct zx_str* zx_hrxml_RelatedOrganizationalUnit_GET_hierarchicalRole(struct zx_hrxml_RelatedOrganizationalUnit_s* x) { return x->hierarchicalRole; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_hierarchicalRole) */
void zx_hrxml_RelatedOrganizationalUnit_PUT_hierarchicalRole(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_str* y) { x->hierarchicalRole = y; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_natureOfRelationship) */
struct zx_str* zx_hrxml_RelatedOrganizationalUnit_GET_natureOfRelationship(struct zx_hrxml_RelatedOrganizationalUnit_s* x) { return x->natureOfRelationship; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_natureOfRelationship) */
void zx_hrxml_RelatedOrganizationalUnit_PUT_natureOfRelationship(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_str* y) { x->natureOfRelationship = y; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_relationship) */
struct zx_str* zx_hrxml_RelatedOrganizationalUnit_GET_relationship(struct zx_hrxml_RelatedOrganizationalUnit_s* x) { return x->relationship; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_relationship) */
void zx_hrxml_RelatedOrganizationalUnit_PUT_relationship(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_str* y) { x->relationship = y; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_GET_typeOfGroup) */
struct zx_str* zx_hrxml_RelatedOrganizationalUnit_GET_typeOfGroup(struct zx_hrxml_RelatedOrganizationalUnit_s* x) { return x->typeOfGroup; }
/* FUNC(zx_hrxml_RelatedOrganizationalUnit_PUT_typeOfGroup) */
void zx_hrxml_RelatedOrganizationalUnit_PUT_typeOfGroup(struct zx_hrxml_RelatedOrganizationalUnit_s* x, struct zx_str* y) { x->typeOfGroup = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelatedPositionPostings_NUM_PositionPosting) */

int zx_hrxml_RelatedPositionPostings_NUM_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x)
{
  struct zx_hrxml_PositionPosting_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PositionPosting; y; ++n, y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelatedPositionPostings_GET_PositionPosting) */

struct zx_hrxml_PositionPosting_s* zx_hrxml_RelatedPositionPostings_GET_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x, int n)
{
  struct zx_hrxml_PositionPosting_s* y;
  if (!x) return 0;
  for (y = x->PositionPosting; n>=0 && y; --n, y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelatedPositionPostings_POP_PositionPosting) */

struct zx_hrxml_PositionPosting_s* zx_hrxml_RelatedPositionPostings_POP_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x)
{
  struct zx_hrxml_PositionPosting_s* y;
  if (!x) return 0;
  y = x->PositionPosting;
  if (y)
    x->PositionPosting = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelatedPositionPostings_PUSH_PositionPosting) */

void zx_hrxml_RelatedPositionPostings_PUSH_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x, struct zx_hrxml_PositionPosting_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PositionPosting->gg.g;
  x->PositionPosting = z;
}

/* FUNC(zx_hrxml_RelatedPositionPostings_REV_PositionPosting) */

void zx_hrxml_RelatedPositionPostings_REV_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x)
{
  struct zx_hrxml_PositionPosting_s* nxt;
  struct zx_hrxml_PositionPosting_s* y;
  if (!x) return;
  y = x->PositionPosting;
  if (!y) return;
  x->PositionPosting = 0;
  while (y) {
    nxt = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n;
    y->gg.g.n = &x->PositionPosting->gg.g;
    x->PositionPosting = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelatedPositionPostings_PUT_PositionPosting) */

void zx_hrxml_RelatedPositionPostings_PUT_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x, int n, struct zx_hrxml_PositionPosting_s* z)
{
  struct zx_hrxml_PositionPosting_s* y;
  if (!x || !z) return;
  y = x->PositionPosting;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PositionPosting = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelatedPositionPostings_ADD_PositionPosting) */

void zx_hrxml_RelatedPositionPostings_ADD_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x, int n, struct zx_hrxml_PositionPosting_s* z)
{
  struct zx_hrxml_PositionPosting_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PositionPosting->gg.g;
    x->PositionPosting = z;
    return;
  case -1:
    y = x->PositionPosting;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionPosting; n > 1 && y; --n, y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelatedPositionPostings_DEL_PositionPosting) */

void zx_hrxml_RelatedPositionPostings_DEL_PositionPosting(struct zx_hrxml_RelatedPositionPostings_s* x, int n)
{
  struct zx_hrxml_PositionPosting_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PositionPosting = (struct zx_hrxml_PositionPosting_s*)x->PositionPosting->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PositionPosting_s*)x->PositionPosting;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PositionPosting; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PositionPosting_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Relocation_NUM_Comments) */

int zx_hrxml_Relocation_NUM_Comments(struct zx_hrxml_Relocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Relocation_GET_Comments) */

struct zx_elem_s* zx_hrxml_Relocation_GET_Comments(struct zx_hrxml_Relocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Relocation_POP_Comments) */

struct zx_elem_s* zx_hrxml_Relocation_POP_Comments(struct zx_hrxml_Relocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Relocation_PUSH_Comments) */

void zx_hrxml_Relocation_PUSH_Comments(struct zx_hrxml_Relocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Relocation_REV_Comments) */

void zx_hrxml_Relocation_REV_Comments(struct zx_hrxml_Relocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Relocation_PUT_Comments) */

void zx_hrxml_Relocation_PUT_Comments(struct zx_hrxml_Relocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Relocation_ADD_Comments) */

void zx_hrxml_Relocation_ADD_Comments(struct zx_hrxml_Relocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Relocation_DEL_Comments) */

void zx_hrxml_Relocation_DEL_Comments(struct zx_hrxml_Relocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Relocation_GET_relocationConsidered) */
struct zx_str* zx_hrxml_Relocation_GET_relocationConsidered(struct zx_hrxml_Relocation_s* x) { return x->relocationConsidered; }
/* FUNC(zx_hrxml_Relocation_PUT_relocationConsidered) */
void zx_hrxml_Relocation_PUT_relocationConsidered(struct zx_hrxml_Relocation_s* x, struct zx_str* y) { x->relocationConsidered = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RelocationAssistance_NUM_Description) */

int zx_hrxml_RelocationAssistance_NUM_Description(struct zx_hrxml_RelocationAssistance_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RelocationAssistance_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelocationAssistance_GET_Description(struct zx_hrxml_RelocationAssistance_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RelocationAssistance_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_RelocationAssistance_POP_Description(struct zx_hrxml_RelocationAssistance_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RelocationAssistance_PUSH_Description) */

void zx_hrxml_RelocationAssistance_PUSH_Description(struct zx_hrxml_RelocationAssistance_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_RelocationAssistance_REV_Description) */

void zx_hrxml_RelocationAssistance_REV_Description(struct zx_hrxml_RelocationAssistance_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RelocationAssistance_PUT_Description) */

void zx_hrxml_RelocationAssistance_PUT_Description(struct zx_hrxml_RelocationAssistance_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RelocationAssistance_ADD_Description) */

void zx_hrxml_RelocationAssistance_ADD_Description(struct zx_hrxml_RelocationAssistance_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RelocationAssistance_DEL_Description) */

void zx_hrxml_RelocationAssistance_DEL_Description(struct zx_hrxml_RelocationAssistance_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_RelocationAssistance_GET_companyOffered) */
struct zx_str* zx_hrxml_RelocationAssistance_GET_companyOffered(struct zx_hrxml_RelocationAssistance_s* x) { return x->companyOffered; }
/* FUNC(zx_hrxml_RelocationAssistance_PUT_companyOffered) */
void zx_hrxml_RelocationAssistance_PUT_companyOffered(struct zx_hrxml_RelocationAssistance_s* x, struct zx_str* y) { x->companyOffered = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RemunerationPackage_NUM_BasePay) */

int zx_hrxml_RemunerationPackage_NUM_BasePay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_BasePay_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->BasePay; y; ++n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RemunerationPackage_GET_BasePay) */

struct zx_hrxml_BasePay_s* zx_hrxml_RemunerationPackage_GET_BasePay(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return 0;
  for (y = x->BasePay; n>=0 && y; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_POP_BasePay) */

struct zx_hrxml_BasePay_s* zx_hrxml_RemunerationPackage_POP_BasePay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return 0;
  y = x->BasePay;
  if (y)
    x->BasePay = (struct zx_hrxml_BasePay_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_PUSH_BasePay) */

void zx_hrxml_RemunerationPackage_PUSH_BasePay(struct zx_hrxml_RemunerationPackage_s* x, struct zx_hrxml_BasePay_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->BasePay->gg.g;
  x->BasePay = z;
}

/* FUNC(zx_hrxml_RemunerationPackage_REV_BasePay) */

void zx_hrxml_RemunerationPackage_REV_BasePay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_BasePay_s* nxt;
  struct zx_hrxml_BasePay_s* y;
  if (!x) return;
  y = x->BasePay;
  if (!y) return;
  x->BasePay = 0;
  while (y) {
    nxt = (struct zx_hrxml_BasePay_s*)y->gg.g.n;
    y->gg.g.n = &x->BasePay->gg.g;
    x->BasePay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_PUT_BasePay) */

void zx_hrxml_RemunerationPackage_PUT_BasePay(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_BasePay_s* z)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x || !z) return;
  y = x->BasePay;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->BasePay = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_ADD_BasePay) */

void zx_hrxml_RemunerationPackage_ADD_BasePay(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_BasePay_s* z)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->BasePay->gg.g;
    x->BasePay = z;
    return;
  case -1:
    y = x->BasePay;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BasePay; n > 1 && y; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RemunerationPackage_DEL_BasePay) */

void zx_hrxml_RemunerationPackage_DEL_BasePay(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_BasePay_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->BasePay = (struct zx_hrxml_BasePay_s*)x->BasePay->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_BasePay_s*)x->BasePay;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->BasePay; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_BasePay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RemunerationPackage_NUM_OtherPay) */

int zx_hrxml_RemunerationPackage_NUM_OtherPay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_OtherPay_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OtherPay; y; ++n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RemunerationPackage_GET_OtherPay) */

struct zx_hrxml_OtherPay_s* zx_hrxml_RemunerationPackage_GET_OtherPay(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return 0;
  for (y = x->OtherPay; n>=0 && y; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_POP_OtherPay) */

struct zx_hrxml_OtherPay_s* zx_hrxml_RemunerationPackage_POP_OtherPay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return 0;
  y = x->OtherPay;
  if (y)
    x->OtherPay = (struct zx_hrxml_OtherPay_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_PUSH_OtherPay) */

void zx_hrxml_RemunerationPackage_PUSH_OtherPay(struct zx_hrxml_RemunerationPackage_s* x, struct zx_hrxml_OtherPay_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OtherPay->gg.g;
  x->OtherPay = z;
}

/* FUNC(zx_hrxml_RemunerationPackage_REV_OtherPay) */

void zx_hrxml_RemunerationPackage_REV_OtherPay(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_OtherPay_s* nxt;
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return;
  y = x->OtherPay;
  if (!y) return;
  x->OtherPay = 0;
  while (y) {
    nxt = (struct zx_hrxml_OtherPay_s*)y->gg.g.n;
    y->gg.g.n = &x->OtherPay->gg.g;
    x->OtherPay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_PUT_OtherPay) */

void zx_hrxml_RemunerationPackage_PUT_OtherPay(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_OtherPay_s* z)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x || !z) return;
  y = x->OtherPay;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OtherPay = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_ADD_OtherPay) */

void zx_hrxml_RemunerationPackage_ADD_OtherPay(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_OtherPay_s* z)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OtherPay->gg.g;
    x->OtherPay = z;
    return;
  case -1:
    y = x->OtherPay;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPay; n > 1 && y; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RemunerationPackage_DEL_OtherPay) */

void zx_hrxml_RemunerationPackage_DEL_OtherPay(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_OtherPay_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OtherPay = (struct zx_hrxml_OtherPay_s*)x->OtherPay->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OtherPay_s*)x->OtherPay;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OtherPay; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OtherPay_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RemunerationPackage_NUM_Benefits) */

int zx_hrxml_RemunerationPackage_NUM_Benefits(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_Benefits_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Benefits; y; ++n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RemunerationPackage_GET_Benefits) */

struct zx_hrxml_Benefits_s* zx_hrxml_RemunerationPackage_GET_Benefits(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return 0;
  for (y = x->Benefits; n>=0 && y; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_POP_Benefits) */

struct zx_hrxml_Benefits_s* zx_hrxml_RemunerationPackage_POP_Benefits(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return 0;
  y = x->Benefits;
  if (y)
    x->Benefits = (struct zx_hrxml_Benefits_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_PUSH_Benefits) */

void zx_hrxml_RemunerationPackage_PUSH_Benefits(struct zx_hrxml_RemunerationPackage_s* x, struct zx_hrxml_Benefits_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Benefits->gg.g;
  x->Benefits = z;
}

/* FUNC(zx_hrxml_RemunerationPackage_REV_Benefits) */

void zx_hrxml_RemunerationPackage_REV_Benefits(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_Benefits_s* nxt;
  struct zx_hrxml_Benefits_s* y;
  if (!x) return;
  y = x->Benefits;
  if (!y) return;
  x->Benefits = 0;
  while (y) {
    nxt = (struct zx_hrxml_Benefits_s*)y->gg.g.n;
    y->gg.g.n = &x->Benefits->gg.g;
    x->Benefits = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_PUT_Benefits) */

void zx_hrxml_RemunerationPackage_PUT_Benefits(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_Benefits_s* z)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x || !z) return;
  y = x->Benefits;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Benefits = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_ADD_Benefits) */

void zx_hrxml_RemunerationPackage_ADD_Benefits(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_Benefits_s* z)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Benefits->gg.g;
    x->Benefits = z;
    return;
  case -1:
    y = x->Benefits;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Benefits; n > 1 && y; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RemunerationPackage_DEL_Benefits) */

void zx_hrxml_RemunerationPackage_DEL_Benefits(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_Benefits_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Benefits = (struct zx_hrxml_Benefits_s*)x->Benefits->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Benefits_s*)x->Benefits;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Benefits; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Benefits_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RemunerationPackage_NUM_UserArea) */

int zx_hrxml_RemunerationPackage_NUM_UserArea(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RemunerationPackage_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RemunerationPackage_GET_UserArea(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_RemunerationPackage_POP_UserArea(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RemunerationPackage_PUSH_UserArea) */

void zx_hrxml_RemunerationPackage_PUSH_UserArea(struct zx_hrxml_RemunerationPackage_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_RemunerationPackage_REV_UserArea) */

void zx_hrxml_RemunerationPackage_REV_UserArea(struct zx_hrxml_RemunerationPackage_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_PUT_UserArea) */

void zx_hrxml_RemunerationPackage_PUT_UserArea(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RemunerationPackage_ADD_UserArea) */

void zx_hrxml_RemunerationPackage_ADD_UserArea(struct zx_hrxml_RemunerationPackage_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RemunerationPackage_DEL_UserArea) */

void zx_hrxml_RemunerationPackage_DEL_UserArea(struct zx_hrxml_RemunerationPackage_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Resume_NUM_ResumeId) */

int zx_hrxml_Resume_NUM_ResumeId(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ResumeId; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Resume_GET_ResumeId) */

struct zx_elem_s* zx_hrxml_Resume_GET_ResumeId(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ResumeId; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Resume_POP_ResumeId) */

struct zx_elem_s* zx_hrxml_Resume_POP_ResumeId(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ResumeId;
  if (y)
    x->ResumeId = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Resume_PUSH_ResumeId) */

void zx_hrxml_Resume_PUSH_ResumeId(struct zx_hrxml_Resume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ResumeId->g;
  x->ResumeId = z;
}

/* FUNC(zx_hrxml_Resume_REV_ResumeId) */

void zx_hrxml_Resume_REV_ResumeId(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ResumeId;
  if (!y) return;
  x->ResumeId = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ResumeId->g;
    x->ResumeId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Resume_PUT_ResumeId) */

void zx_hrxml_Resume_PUT_ResumeId(struct zx_hrxml_Resume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ResumeId;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ResumeId = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Resume_ADD_ResumeId) */

void zx_hrxml_Resume_ADD_ResumeId(struct zx_hrxml_Resume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ResumeId->g;
    x->ResumeId = z;
    return;
  case -1:
    y = x->ResumeId;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ResumeId; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Resume_DEL_ResumeId) */

void zx_hrxml_Resume_DEL_ResumeId(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ResumeId = (struct zx_elem_s*)x->ResumeId->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ResumeId;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ResumeId; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Resume_NUM_DistributionGuidelines) */

int zx_hrxml_Resume_NUM_DistributionGuidelines(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Resume_GET_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_Resume_GET_DistributionGuidelines(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DistributionGuidelines; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Resume_POP_DistributionGuidelines) */

struct zx_elem_s* zx_hrxml_Resume_POP_DistributionGuidelines(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DistributionGuidelines;
  if (y)
    x->DistributionGuidelines = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Resume_PUSH_DistributionGuidelines) */

void zx_hrxml_Resume_PUSH_DistributionGuidelines(struct zx_hrxml_Resume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DistributionGuidelines->g;
  x->DistributionGuidelines = z;
}

/* FUNC(zx_hrxml_Resume_REV_DistributionGuidelines) */

void zx_hrxml_Resume_REV_DistributionGuidelines(struct zx_hrxml_Resume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  x->DistributionGuidelines = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Resume_PUT_DistributionGuidelines) */

void zx_hrxml_Resume_PUT_DistributionGuidelines(struct zx_hrxml_Resume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DistributionGuidelines;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DistributionGuidelines = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Resume_ADD_DistributionGuidelines) */

void zx_hrxml_Resume_ADD_DistributionGuidelines(struct zx_hrxml_Resume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DistributionGuidelines->g;
    x->DistributionGuidelines = z;
    return;
  case -1:
    y = x->DistributionGuidelines;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Resume_DEL_DistributionGuidelines) */

void zx_hrxml_Resume_DEL_DistributionGuidelines(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DistributionGuidelines = (struct zx_elem_s*)x->DistributionGuidelines->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DistributionGuidelines;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DistributionGuidelines; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Resume_NUM_StructuredXMLResume) */

int zx_hrxml_Resume_NUM_StructuredXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StructuredXMLResume; y; ++n, y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Resume_GET_StructuredXMLResume) */

struct zx_hrxml_StructuredXMLResume_s* zx_hrxml_Resume_GET_StructuredXMLResume(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x) return 0;
  for (y = x->StructuredXMLResume; n>=0 && y; --n, y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Resume_POP_StructuredXMLResume) */

struct zx_hrxml_StructuredXMLResume_s* zx_hrxml_Resume_POP_StructuredXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x) return 0;
  y = x->StructuredXMLResume;
  if (y)
    x->StructuredXMLResume = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Resume_PUSH_StructuredXMLResume) */

void zx_hrxml_Resume_PUSH_StructuredXMLResume(struct zx_hrxml_Resume_s* x, struct zx_hrxml_StructuredXMLResume_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StructuredXMLResume->gg.g;
  x->StructuredXMLResume = z;
}

/* FUNC(zx_hrxml_Resume_REV_StructuredXMLResume) */

void zx_hrxml_Resume_REV_StructuredXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_StructuredXMLResume_s* nxt;
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x) return;
  y = x->StructuredXMLResume;
  if (!y) return;
  x->StructuredXMLResume = 0;
  while (y) {
    nxt = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n;
    y->gg.g.n = &x->StructuredXMLResume->gg.g;
    x->StructuredXMLResume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Resume_PUT_StructuredXMLResume) */

void zx_hrxml_Resume_PUT_StructuredXMLResume(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_StructuredXMLResume_s* z)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x || !z) return;
  y = x->StructuredXMLResume;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StructuredXMLResume = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Resume_ADD_StructuredXMLResume) */

void zx_hrxml_Resume_ADD_StructuredXMLResume(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_StructuredXMLResume_s* z)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StructuredXMLResume->gg.g;
    x->StructuredXMLResume = z;
    return;
  case -1:
    y = x->StructuredXMLResume;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StructuredXMLResume; n > 1 && y; --n, y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Resume_DEL_StructuredXMLResume) */

void zx_hrxml_Resume_DEL_StructuredXMLResume(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_StructuredXMLResume_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StructuredXMLResume = (struct zx_hrxml_StructuredXMLResume_s*)x->StructuredXMLResume->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StructuredXMLResume_s*)x->StructuredXMLResume;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StructuredXMLResume; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StructuredXMLResume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Resume_NUM_NonXMLResume) */

int zx_hrxml_Resume_NUM_NonXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_NonXMLResume_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NonXMLResume; y; ++n, y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Resume_GET_NonXMLResume) */

struct zx_hrxml_NonXMLResume_s* zx_hrxml_Resume_GET_NonXMLResume(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x) return 0;
  for (y = x->NonXMLResume; n>=0 && y; --n, y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Resume_POP_NonXMLResume) */

struct zx_hrxml_NonXMLResume_s* zx_hrxml_Resume_POP_NonXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x) return 0;
  y = x->NonXMLResume;
  if (y)
    x->NonXMLResume = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Resume_PUSH_NonXMLResume) */

void zx_hrxml_Resume_PUSH_NonXMLResume(struct zx_hrxml_Resume_s* x, struct zx_hrxml_NonXMLResume_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->NonXMLResume->gg.g;
  x->NonXMLResume = z;
}

/* FUNC(zx_hrxml_Resume_REV_NonXMLResume) */

void zx_hrxml_Resume_REV_NonXMLResume(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_NonXMLResume_s* nxt;
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x) return;
  y = x->NonXMLResume;
  if (!y) return;
  x->NonXMLResume = 0;
  while (y) {
    nxt = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n;
    y->gg.g.n = &x->NonXMLResume->gg.g;
    x->NonXMLResume = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Resume_PUT_NonXMLResume) */

void zx_hrxml_Resume_PUT_NonXMLResume(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_NonXMLResume_s* z)
{
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x || !z) return;
  y = x->NonXMLResume;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->NonXMLResume = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Resume_ADD_NonXMLResume) */

void zx_hrxml_Resume_ADD_NonXMLResume(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_NonXMLResume_s* z)
{
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->NonXMLResume->gg.g;
    x->NonXMLResume = z;
    return;
  case -1:
    y = x->NonXMLResume;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NonXMLResume; n > 1 && y; --n, y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Resume_DEL_NonXMLResume) */

void zx_hrxml_Resume_DEL_NonXMLResume(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_NonXMLResume_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NonXMLResume = (struct zx_hrxml_NonXMLResume_s*)x->NonXMLResume->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_NonXMLResume_s*)x->NonXMLResume;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->NonXMLResume; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_NonXMLResume_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Resume_NUM_UserArea) */

int zx_hrxml_Resume_NUM_UserArea(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Resume_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Resume_GET_UserArea(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Resume_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_Resume_POP_UserArea(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Resume_PUSH_UserArea) */

void zx_hrxml_Resume_PUSH_UserArea(struct zx_hrxml_Resume_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_Resume_REV_UserArea) */

void zx_hrxml_Resume_REV_UserArea(struct zx_hrxml_Resume_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Resume_PUT_UserArea) */

void zx_hrxml_Resume_PUT_UserArea(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Resume_ADD_UserArea) */

void zx_hrxml_Resume_ADD_UserArea(struct zx_hrxml_Resume_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Resume_DEL_UserArea) */

void zx_hrxml_Resume_DEL_UserArea(struct zx_hrxml_Resume_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_Resume_GET_lang) */
struct zx_str* zx_hrxml_Resume_GET_lang(struct zx_hrxml_Resume_s* x) { return x->lang; }
/* FUNC(zx_hrxml_Resume_PUT_lang) */
void zx_hrxml_Resume_PUT_lang(struct zx_hrxml_Resume_s* x, struct zx_str* y) { x->lang = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ResumeAdditionalItem_NUM_EffectiveDate) */

int zx_hrxml_ResumeAdditionalItem_NUM_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EffectiveDate; y; ++n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_GET_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_ResumeAdditionalItem_GET_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  for (y = x->EffectiveDate; n>=0 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_POP_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_ResumeAdditionalItem_POP_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  y = x->EffectiveDate;
  if (y)
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_PUSH_EffectiveDate) */

void zx_hrxml_ResumeAdditionalItem_PUSH_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x, struct zx_hrxml_EffectiveDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EffectiveDate->gg.g;
  x->EffectiveDate = z;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_REV_EffectiveDate) */

void zx_hrxml_ResumeAdditionalItem_REV_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_EffectiveDate_s* nxt;
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  y = x->EffectiveDate;
  if (!y) return;
  x->EffectiveDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_PUT_EffectiveDate) */

void zx_hrxml_ResumeAdditionalItem_PUT_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  y = x->EffectiveDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EffectiveDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_ADD_EffectiveDate) */

void zx_hrxml_ResumeAdditionalItem_ADD_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = z;
    return;
  case -1:
    y = x->EffectiveDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_DEL_EffectiveDate) */

void zx_hrxml_ResumeAdditionalItem_DEL_EffectiveDate(struct zx_hrxml_ResumeAdditionalItem_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ResumeAdditionalItem_NUM_Description) */

int zx_hrxml_ResumeAdditionalItem_NUM_Description(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_ResumeAdditionalItem_GET_Description(struct zx_hrxml_ResumeAdditionalItem_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_ResumeAdditionalItem_POP_Description(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_PUSH_Description) */

void zx_hrxml_ResumeAdditionalItem_PUSH_Description(struct zx_hrxml_ResumeAdditionalItem_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_REV_Description) */

void zx_hrxml_ResumeAdditionalItem_REV_Description(struct zx_hrxml_ResumeAdditionalItem_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_PUT_Description) */

void zx_hrxml_ResumeAdditionalItem_PUT_Description(struct zx_hrxml_ResumeAdditionalItem_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_ADD_Description) */

void zx_hrxml_ResumeAdditionalItem_ADD_Description(struct zx_hrxml_ResumeAdditionalItem_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ResumeAdditionalItem_DEL_Description) */

void zx_hrxml_ResumeAdditionalItem_DEL_Description(struct zx_hrxml_ResumeAdditionalItem_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ResumeAdditionalItem_GET_type) */
struct zx_str* zx_hrxml_ResumeAdditionalItem_GET_type(struct zx_hrxml_ResumeAdditionalItem_s* x) { return x->type; }
/* FUNC(zx_hrxml_ResumeAdditionalItem_PUT_type) */
void zx_hrxml_ResumeAdditionalItem_PUT_type(struct zx_hrxml_ResumeAdditionalItem_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ResumeAdditionalItems_NUM_ResumeAdditionalItem) */

int zx_hrxml_ResumeAdditionalItems_NUM_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ResumeAdditionalItem; y; ++n, y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_GET_ResumeAdditionalItem) */

struct zx_hrxml_ResumeAdditionalItem_s* zx_hrxml_ResumeAdditionalItems_GET_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x, int n)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x) return 0;
  for (y = x->ResumeAdditionalItem; n>=0 && y; --n, y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_POP_ResumeAdditionalItem) */

struct zx_hrxml_ResumeAdditionalItem_s* zx_hrxml_ResumeAdditionalItems_POP_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x) return 0;
  y = x->ResumeAdditionalItem;
  if (y)
    x->ResumeAdditionalItem = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_PUSH_ResumeAdditionalItem) */

void zx_hrxml_ResumeAdditionalItems_PUSH_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x, struct zx_hrxml_ResumeAdditionalItem_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ResumeAdditionalItem->gg.g;
  x->ResumeAdditionalItem = z;
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_REV_ResumeAdditionalItem) */

void zx_hrxml_ResumeAdditionalItems_REV_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x)
{
  struct zx_hrxml_ResumeAdditionalItem_s* nxt;
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x) return;
  y = x->ResumeAdditionalItem;
  if (!y) return;
  x->ResumeAdditionalItem = 0;
  while (y) {
    nxt = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n;
    y->gg.g.n = &x->ResumeAdditionalItem->gg.g;
    x->ResumeAdditionalItem = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_PUT_ResumeAdditionalItem) */

void zx_hrxml_ResumeAdditionalItems_PUT_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x, int n, struct zx_hrxml_ResumeAdditionalItem_s* z)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x || !z) return;
  y = x->ResumeAdditionalItem;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ResumeAdditionalItem = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_ADD_ResumeAdditionalItem) */

void zx_hrxml_ResumeAdditionalItems_ADD_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x, int n, struct zx_hrxml_ResumeAdditionalItem_s* z)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ResumeAdditionalItem->gg.g;
    x->ResumeAdditionalItem = z;
    return;
  case -1:
    y = x->ResumeAdditionalItem;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ResumeAdditionalItem; n > 1 && y; --n, y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ResumeAdditionalItems_DEL_ResumeAdditionalItem) */

void zx_hrxml_ResumeAdditionalItems_DEL_ResumeAdditionalItem(struct zx_hrxml_ResumeAdditionalItems_s* x, int n)
{
  struct zx_hrxml_ResumeAdditionalItem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ResumeAdditionalItem = (struct zx_hrxml_ResumeAdditionalItem_s*)x->ResumeAdditionalItem->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ResumeAdditionalItem_s*)x->ResumeAdditionalItem;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ResumeAdditionalItem; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ResumeAdditionalItem_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_RoleId_NUM_IdValue) */

int zx_hrxml_RoleId_NUM_IdValue(struct zx_hrxml_RoleId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_RoleId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_RoleId_GET_IdValue(struct zx_hrxml_RoleId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_RoleId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_RoleId_POP_IdValue(struct zx_hrxml_RoleId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_RoleId_PUSH_IdValue) */

void zx_hrxml_RoleId_PUSH_IdValue(struct zx_hrxml_RoleId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_RoleId_REV_IdValue) */

void zx_hrxml_RoleId_REV_IdValue(struct zx_hrxml_RoleId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_RoleId_PUT_IdValue) */

void zx_hrxml_RoleId_PUT_IdValue(struct zx_hrxml_RoleId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_RoleId_ADD_IdValue) */

void zx_hrxml_RoleId_ADD_IdValue(struct zx_hrxml_RoleId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_RoleId_DEL_IdValue) */

void zx_hrxml_RoleId_DEL_IdValue(struct zx_hrxml_RoleId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_RoleId_GET_idOwner) */
struct zx_str* zx_hrxml_RoleId_GET_idOwner(struct zx_hrxml_RoleId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_RoleId_PUT_idOwner) */
void zx_hrxml_RoleId_PUT_idOwner(struct zx_hrxml_RoleId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_RoleId_GET_validFrom) */
struct zx_str* zx_hrxml_RoleId_GET_validFrom(struct zx_hrxml_RoleId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_RoleId_PUT_validFrom) */
void zx_hrxml_RoleId_PUT_validFrom(struct zx_hrxml_RoleId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_RoleId_GET_validTo) */
struct zx_str* zx_hrxml_RoleId_GET_validTo(struct zx_hrxml_RoleId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_RoleId_PUT_validTo) */
void zx_hrxml_RoleId_PUT_validTo(struct zx_hrxml_RoleId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_Id) */

int zx_hrxml_SEPPhysicalLocation_NUM_Id(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_SEPPhysicalLocation_GET_Id(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_SEPPhysicalLocation_POP_Id(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_Id) */

void zx_hrxml_SEPPhysicalLocation_PUSH_Id(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_Id) */

void zx_hrxml_SEPPhysicalLocation_REV_Id(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_Id) */

void zx_hrxml_SEPPhysicalLocation_PUT_Id(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_Id) */

void zx_hrxml_SEPPhysicalLocation_ADD_Id(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_Id) */

void zx_hrxml_SEPPhysicalLocation_DEL_Id(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_Name) */

int zx_hrxml_SEPPhysicalLocation_NUM_Name(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_Name) */

struct zx_elem_s* zx_hrxml_SEPPhysicalLocation_GET_Name(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_Name) */

struct zx_elem_s* zx_hrxml_SEPPhysicalLocation_POP_Name(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_Name) */

void zx_hrxml_SEPPhysicalLocation_PUSH_Name(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_Name) */

void zx_hrxml_SEPPhysicalLocation_REV_Name(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_Name) */

void zx_hrxml_SEPPhysicalLocation_PUT_Name(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_Name) */

void zx_hrxml_SEPPhysicalLocation_ADD_Name(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_Name) */

void zx_hrxml_SEPPhysicalLocation_DEL_Name(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_SpatialLocation) */

int zx_hrxml_SEPPhysicalLocation_NUM_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SpatialLocation; y; ++n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_SpatialLocation) */

struct zx_hrxml_SpatialLocation_s* zx_hrxml_SEPPhysicalLocation_GET_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return 0;
  for (y = x->SpatialLocation; n>=0 && y; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_SpatialLocation) */

struct zx_hrxml_SpatialLocation_s* zx_hrxml_SEPPhysicalLocation_POP_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return 0;
  y = x->SpatialLocation;
  if (y)
    x->SpatialLocation = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_SpatialLocation) */

void zx_hrxml_SEPPhysicalLocation_PUSH_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_hrxml_SpatialLocation_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SpatialLocation->gg.g;
  x->SpatialLocation = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_SpatialLocation) */

void zx_hrxml_SEPPhysicalLocation_REV_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_SpatialLocation_s* nxt;
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return;
  y = x->SpatialLocation;
  if (!y) return;
  x->SpatialLocation = 0;
  while (y) {
    nxt = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n;
    y->gg.g.n = &x->SpatialLocation->gg.g;
    x->SpatialLocation = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_SpatialLocation) */

void zx_hrxml_SEPPhysicalLocation_PUT_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_SpatialLocation_s* z)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x || !z) return;
  y = x->SpatialLocation;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SpatialLocation = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_SpatialLocation) */

void zx_hrxml_SEPPhysicalLocation_ADD_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_SpatialLocation_s* z)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SpatialLocation->gg.g;
    x->SpatialLocation = z;
    return;
  case -1:
    y = x->SpatialLocation;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpatialLocation; n > 1 && y; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_SpatialLocation) */

void zx_hrxml_SEPPhysicalLocation_DEL_SpatialLocation(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_SpatialLocation_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SpatialLocation = (struct zx_hrxml_SpatialLocation_s*)x->SpatialLocation->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SpatialLocation_s*)x->SpatialLocation;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpatialLocation; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpatialLocation_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_TravelDirections) */

int zx_hrxml_SEPPhysicalLocation_NUM_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TravelDirections; y; ++n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_SEPPhysicalLocation_GET_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  for (y = x->TravelDirections; n>=0 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_SEPPhysicalLocation_POP_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  y = x->TravelDirections;
  if (y)
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_TravelDirections) */

void zx_hrxml_SEPPhysicalLocation_PUSH_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_hrxml_TravelDirections_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TravelDirections->gg.g;
  x->TravelDirections = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_TravelDirections) */

void zx_hrxml_SEPPhysicalLocation_REV_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_TravelDirections_s* nxt;
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  y = x->TravelDirections;
  if (!y) return;
  x->TravelDirections = 0;
  while (y) {
    nxt = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
    y->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_TravelDirections) */

void zx_hrxml_SEPPhysicalLocation_PUT_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  y = x->TravelDirections;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TravelDirections = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_TravelDirections) */

void zx_hrxml_SEPPhysicalLocation_ADD_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = z;
    return;
  case -1:
    y = x->TravelDirections;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_TravelDirections) */

void zx_hrxml_SEPPhysicalLocation_DEL_TravelDirections(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_Area) */

int zx_hrxml_SEPPhysicalLocation_NUM_Area(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Area; y; ++n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_Area) */

struct zx_hrxml_Area_s* zx_hrxml_SEPPhysicalLocation_GET_Area(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  for (y = x->Area; n>=0 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_Area) */

struct zx_hrxml_Area_s* zx_hrxml_SEPPhysicalLocation_POP_Area(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return 0;
  y = x->Area;
  if (y)
    x->Area = (struct zx_hrxml_Area_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_Area) */

void zx_hrxml_SEPPhysicalLocation_PUSH_Area(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_hrxml_Area_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Area->gg.g;
  x->Area = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_Area) */

void zx_hrxml_SEPPhysicalLocation_REV_Area(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_Area_s* nxt;
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  y = x->Area;
  if (!y) return;
  x->Area = 0;
  while (y) {
    nxt = (struct zx_hrxml_Area_s*)y->gg.g.n;
    y->gg.g.n = &x->Area->gg.g;
    x->Area = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_Area) */

void zx_hrxml_SEPPhysicalLocation_PUT_Area(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  y = x->Area;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Area = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_Area) */

void zx_hrxml_SEPPhysicalLocation_ADD_Area(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_Area_s* z)
{
  struct zx_hrxml_Area_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Area->gg.g;
    x->Area = z;
    return;
  case -1:
    y = x->Area;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_Area) */

void zx_hrxml_SEPPhysicalLocation_DEL_Area(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_Area_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Area = (struct zx_hrxml_Area_s*)x->Area->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Area_s*)x->Area;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Area; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Area_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_PostalAddress) */

int zx_hrxml_SEPPhysicalLocation_NUM_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalAddress; y; ++n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_SEPPhysicalLocation_GET_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  for (y = x->PostalAddress; n>=0 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_SEPPhysicalLocation_POP_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  y = x->PostalAddress;
  if (y)
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_PostalAddress) */

void zx_hrxml_SEPPhysicalLocation_PUSH_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_hrxml_PostalAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PostalAddress->gg.g;
  x->PostalAddress = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_PostalAddress) */

void zx_hrxml_SEPPhysicalLocation_REV_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_hrxml_PostalAddress_s* nxt;
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  y = x->PostalAddress;
  if (!y) return;
  x->PostalAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_PostalAddress) */

void zx_hrxml_SEPPhysicalLocation_PUT_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  y = x->PostalAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PostalAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_PostalAddress) */

void zx_hrxml_SEPPhysicalLocation_ADD_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = z;
    return;
  case -1:
    y = x->PostalAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_PostalAddress) */

void zx_hrxml_SEPPhysicalLocation_DEL_PostalAddress(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SEPPhysicalLocation_NUM_Comments) */

int zx_hrxml_SEPPhysicalLocation_NUM_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_GET_Comments) */

struct zx_elem_s* zx_hrxml_SEPPhysicalLocation_GET_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_POP_Comments) */

struct zx_elem_s* zx_hrxml_SEPPhysicalLocation_POP_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUSH_Comments) */

void zx_hrxml_SEPPhysicalLocation_PUSH_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_REV_Comments) */

void zx_hrxml_SEPPhysicalLocation_REV_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_PUT_Comments) */

void zx_hrxml_SEPPhysicalLocation_PUT_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_ADD_Comments) */

void zx_hrxml_SEPPhysicalLocation_ADD_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SEPPhysicalLocation_DEL_Comments) */

void zx_hrxml_SEPPhysicalLocation_DEL_Comments(struct zx_hrxml_SEPPhysicalLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_SafetyEquipment_GET_suppliedByOrganization) */
struct zx_str* zx_hrxml_SafetyEquipment_GET_suppliedByOrganization(struct zx_hrxml_SafetyEquipment_s* x) { return x->suppliedByOrganization; }
/* FUNC(zx_hrxml_SafetyEquipment_PUT_suppliedByOrganization) */
void zx_hrxml_SafetyEquipment_PUT_suppliedByOrganization(struct zx_hrxml_SafetyEquipment_s* x, struct zx_str* y) { x->suppliedByOrganization = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_School_NUM_InternetDomainName) */

int zx_hrxml_School_NUM_InternetDomainName(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->InternetDomainName; y; ++n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_School_GET_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_School_GET_InternetDomainName(struct zx_hrxml_School_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  for (y = x->InternetDomainName; n>=0 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_School_POP_InternetDomainName) */

struct zx_hrxml_InternetDomainName_s* zx_hrxml_School_POP_InternetDomainName(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return 0;
  y = x->InternetDomainName;
  if (y)
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_School_PUSH_InternetDomainName) */

void zx_hrxml_School_PUSH_InternetDomainName(struct zx_hrxml_School_s* x, struct zx_hrxml_InternetDomainName_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->InternetDomainName->gg.g;
  x->InternetDomainName = z;
}

/* FUNC(zx_hrxml_School_REV_InternetDomainName) */

void zx_hrxml_School_REV_InternetDomainName(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_InternetDomainName_s* nxt;
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  y = x->InternetDomainName;
  if (!y) return;
  x->InternetDomainName = 0;
  while (y) {
    nxt = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n;
    y->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_School_PUT_InternetDomainName) */

void zx_hrxml_School_PUT_InternetDomainName(struct zx_hrxml_School_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  y = x->InternetDomainName;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->InternetDomainName = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_School_ADD_InternetDomainName) */

void zx_hrxml_School_ADD_InternetDomainName(struct zx_hrxml_School_s* x, int n, struct zx_hrxml_InternetDomainName_s* z)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->InternetDomainName->gg.g;
    x->InternetDomainName = z;
    return;
  case -1:
    y = x->InternetDomainName;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_School_DEL_InternetDomainName) */

void zx_hrxml_School_DEL_InternetDomainName(struct zx_hrxml_School_s* x, int n)
{
  struct zx_hrxml_InternetDomainName_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->InternetDomainName = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_InternetDomainName_s*)x->InternetDomainName;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->InternetDomainName; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_InternetDomainName_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_School_NUM_SchoolId) */

int zx_hrxml_School_NUM_SchoolId(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_SchoolId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SchoolId; y; ++n, y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_School_GET_SchoolId) */

struct zx_hrxml_SchoolId_s* zx_hrxml_School_GET_SchoolId(struct zx_hrxml_School_s* x, int n)
{
  struct zx_hrxml_SchoolId_s* y;
  if (!x) return 0;
  for (y = x->SchoolId; n>=0 && y; --n, y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_School_POP_SchoolId) */

struct zx_hrxml_SchoolId_s* zx_hrxml_School_POP_SchoolId(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_SchoolId_s* y;
  if (!x) return 0;
  y = x->SchoolId;
  if (y)
    x->SchoolId = (struct zx_hrxml_SchoolId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_School_PUSH_SchoolId) */

void zx_hrxml_School_PUSH_SchoolId(struct zx_hrxml_School_s* x, struct zx_hrxml_SchoolId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SchoolId->gg.g;
  x->SchoolId = z;
}

/* FUNC(zx_hrxml_School_REV_SchoolId) */

void zx_hrxml_School_REV_SchoolId(struct zx_hrxml_School_s* x)
{
  struct zx_hrxml_SchoolId_s* nxt;
  struct zx_hrxml_SchoolId_s* y;
  if (!x) return;
  y = x->SchoolId;
  if (!y) return;
  x->SchoolId = 0;
  while (y) {
    nxt = (struct zx_hrxml_SchoolId_s*)y->gg.g.n;
    y->gg.g.n = &x->SchoolId->gg.g;
    x->SchoolId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_School_PUT_SchoolId) */

void zx_hrxml_School_PUT_SchoolId(struct zx_hrxml_School_s* x, int n, struct zx_hrxml_SchoolId_s* z)
{
  struct zx_hrxml_SchoolId_s* y;
  if (!x || !z) return;
  y = x->SchoolId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SchoolId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_School_ADD_SchoolId) */

void zx_hrxml_School_ADD_SchoolId(struct zx_hrxml_School_s* x, int n, struct zx_hrxml_SchoolId_s* z)
{
  struct zx_hrxml_SchoolId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SchoolId->gg.g;
    x->SchoolId = z;
    return;
  case -1:
    y = x->SchoolId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SchoolId; n > 1 && y; --n, y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_School_DEL_SchoolId) */

void zx_hrxml_School_DEL_SchoolId(struct zx_hrxml_School_s* x, int n)
{
  struct zx_hrxml_SchoolId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SchoolId = (struct zx_hrxml_SchoolId_s*)x->SchoolId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SchoolId_s*)x->SchoolId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SchoolId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SchoolId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_School_NUM_SchoolName) */

int zx_hrxml_School_NUM_SchoolName(struct zx_hrxml_School_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SchoolName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_School_GET_SchoolName) */

struct zx_elem_s* zx_hrxml_School_GET_SchoolName(struct zx_hrxml_School_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SchoolName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_School_POP_SchoolName) */

struct zx_elem_s* zx_hrxml_School_POP_SchoolName(struct zx_hrxml_School_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SchoolName;
  if (y)
    x->SchoolName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_School_PUSH_SchoolName) */

void zx_hrxml_School_PUSH_SchoolName(struct zx_hrxml_School_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SchoolName->g;
  x->SchoolName = z;
}

/* FUNC(zx_hrxml_School_REV_SchoolName) */

void zx_hrxml_School_REV_SchoolName(struct zx_hrxml_School_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SchoolName;
  if (!y) return;
  x->SchoolName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SchoolName->g;
    x->SchoolName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_School_PUT_SchoolName) */

void zx_hrxml_School_PUT_SchoolName(struct zx_hrxml_School_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SchoolName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SchoolName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_School_ADD_SchoolName) */

void zx_hrxml_School_ADD_SchoolName(struct zx_hrxml_School_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SchoolName->g;
    x->SchoolName = z;
    return;
  case -1:
    y = x->SchoolName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SchoolName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_School_DEL_SchoolName) */

void zx_hrxml_School_DEL_SchoolName(struct zx_hrxml_School_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SchoolName = (struct zx_elem_s*)x->SchoolName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SchoolName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SchoolName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_School_GET_type) */
struct zx_str* zx_hrxml_School_GET_type(struct zx_hrxml_School_s* x) { return x->type; }
/* FUNC(zx_hrxml_School_PUT_type) */
void zx_hrxml_School_PUT_type(struct zx_hrxml_School_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolId_NUM_IdValue) */

int zx_hrxml_SchoolId_NUM_IdValue(struct zx_hrxml_SchoolId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SchoolId_GET_IdValue(struct zx_hrxml_SchoolId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SchoolId_POP_IdValue(struct zx_hrxml_SchoolId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolId_PUSH_IdValue) */

void zx_hrxml_SchoolId_PUSH_IdValue(struct zx_hrxml_SchoolId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_SchoolId_REV_IdValue) */

void zx_hrxml_SchoolId_REV_IdValue(struct zx_hrxml_SchoolId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolId_PUT_IdValue) */

void zx_hrxml_SchoolId_PUT_IdValue(struct zx_hrxml_SchoolId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolId_ADD_IdValue) */

void zx_hrxml_SchoolId_ADD_IdValue(struct zx_hrxml_SchoolId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolId_DEL_IdValue) */

void zx_hrxml_SchoolId_DEL_IdValue(struct zx_hrxml_SchoolId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_SchoolId_GET_idOwner) */
struct zx_str* zx_hrxml_SchoolId_GET_idOwner(struct zx_hrxml_SchoolId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_SchoolId_PUT_idOwner) */
void zx_hrxml_SchoolId_PUT_idOwner(struct zx_hrxml_SchoolId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_SchoolId_GET_validFrom) */
struct zx_str* zx_hrxml_SchoolId_GET_validFrom(struct zx_hrxml_SchoolId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_SchoolId_PUT_validFrom) */
void zx_hrxml_SchoolId_PUT_validFrom(struct zx_hrxml_SchoolId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_SchoolId_GET_validTo) */
struct zx_str* zx_hrxml_SchoolId_GET_validTo(struct zx_hrxml_SchoolId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_SchoolId_PUT_validTo) */
void zx_hrxml_SchoolId_PUT_validTo(struct zx_hrxml_SchoolId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_SchoolName) */

int zx_hrxml_SchoolOrInstitution_NUM_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SchoolName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_SchoolName) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_GET_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SchoolName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_SchoolName) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_POP_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SchoolName;
  if (y)
    x->SchoolName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_SchoolName) */

void zx_hrxml_SchoolOrInstitution_PUSH_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SchoolName->g;
  x->SchoolName = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_SchoolName) */

void zx_hrxml_SchoolOrInstitution_REV_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SchoolName;
  if (!y) return;
  x->SchoolName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SchoolName->g;
    x->SchoolName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_SchoolName) */

void zx_hrxml_SchoolOrInstitution_PUT_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SchoolName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SchoolName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_SchoolName) */

void zx_hrxml_SchoolOrInstitution_ADD_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SchoolName->g;
    x->SchoolName = z;
    return;
  case -1:
    y = x->SchoolName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SchoolName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_SchoolName) */

void zx_hrxml_SchoolOrInstitution_DEL_SchoolName(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SchoolName = (struct zx_elem_s*)x->SchoolName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SchoolName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SchoolName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_School) */

int zx_hrxml_SchoolOrInstitution_NUM_School(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_School_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->School; y; ++n, y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_School) */

struct zx_hrxml_School_s* zx_hrxml_SchoolOrInstitution_GET_School(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_School_s* y;
  if (!x) return 0;
  for (y = x->School; n>=0 && y; --n, y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_School) */

struct zx_hrxml_School_s* zx_hrxml_SchoolOrInstitution_POP_School(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_School_s* y;
  if (!x) return 0;
  y = x->School;
  if (y)
    x->School = (struct zx_hrxml_School_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_School) */

void zx_hrxml_SchoolOrInstitution_PUSH_School(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_School_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->School->gg.g;
  x->School = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_School) */

void zx_hrxml_SchoolOrInstitution_REV_School(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_School_s* nxt;
  struct zx_hrxml_School_s* y;
  if (!x) return;
  y = x->School;
  if (!y) return;
  x->School = 0;
  while (y) {
    nxt = (struct zx_hrxml_School_s*)y->gg.g.n;
    y->gg.g.n = &x->School->gg.g;
    x->School = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_School) */

void zx_hrxml_SchoolOrInstitution_PUT_School(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_School_s* z)
{
  struct zx_hrxml_School_s* y;
  if (!x || !z) return;
  y = x->School;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->School = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_School) */

void zx_hrxml_SchoolOrInstitution_ADD_School(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_School_s* z)
{
  struct zx_hrxml_School_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->School->gg.g;
    x->School = z;
    return;
  case -1:
    y = x->School;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->School; n > 1 && y; --n, y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_School) */

void zx_hrxml_SchoolOrInstitution_DEL_School(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_School_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->School = (struct zx_hrxml_School_s*)x->School->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_School_s*)x->School;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->School; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_School_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_LocationSummary) */

int zx_hrxml_SchoolOrInstitution_NUM_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LocationSummary; y; ++n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_SchoolOrInstitution_GET_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  for (y = x->LocationSummary; n>=0 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_LocationSummary) */

struct zx_hrxml_LocationSummary_s* zx_hrxml_SchoolOrInstitution_POP_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return 0;
  y = x->LocationSummary;
  if (y)
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_LocationSummary) */

void zx_hrxml_SchoolOrInstitution_PUSH_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_LocationSummary_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LocationSummary->gg.g;
  x->LocationSummary = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_LocationSummary) */

void zx_hrxml_SchoolOrInstitution_REV_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocationSummary_s* nxt;
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  y = x->LocationSummary;
  if (!y) return;
  x->LocationSummary = 0;
  while (y) {
    nxt = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n;
    y->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_LocationSummary) */

void zx_hrxml_SchoolOrInstitution_PUT_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  y = x->LocationSummary;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LocationSummary = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_LocationSummary) */

void zx_hrxml_SchoolOrInstitution_ADD_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_LocationSummary_s* z)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LocationSummary->gg.g;
    x->LocationSummary = z;
    return;
  case -1:
    y = x->LocationSummary;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_LocationSummary) */

void zx_hrxml_SchoolOrInstitution_DEL_LocationSummary(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_LocationSummary_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LocationSummary = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LocationSummary_s*)x->LocationSummary;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocationSummary; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocationSummary_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_PostalAddress) */

int zx_hrxml_SchoolOrInstitution_NUM_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalAddress; y; ++n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_SchoolOrInstitution_GET_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  for (y = x->PostalAddress; n>=0 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_SchoolOrInstitution_POP_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  y = x->PostalAddress;
  if (y)
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_PostalAddress) */

void zx_hrxml_SchoolOrInstitution_PUSH_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_PostalAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PostalAddress->gg.g;
  x->PostalAddress = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_PostalAddress) */

void zx_hrxml_SchoolOrInstitution_REV_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_PostalAddress_s* nxt;
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  y = x->PostalAddress;
  if (!y) return;
  x->PostalAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_PostalAddress) */

void zx_hrxml_SchoolOrInstitution_PUT_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  y = x->PostalAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PostalAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_PostalAddress) */

void zx_hrxml_SchoolOrInstitution_ADD_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = z;
    return;
  case -1:
    y = x->PostalAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_PostalAddress) */

void zx_hrxml_SchoolOrInstitution_DEL_PostalAddress(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_OrganizationUnit) */

int zx_hrxml_SchoolOrInstitution_NUM_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OrganizationUnit; y; ++n, y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_OrganizationUnit) */

struct zx_hrxml_OrganizationUnit_s* zx_hrxml_SchoolOrInstitution_GET_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x) return 0;
  for (y = x->OrganizationUnit; n>=0 && y; --n, y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_OrganizationUnit) */

struct zx_hrxml_OrganizationUnit_s* zx_hrxml_SchoolOrInstitution_POP_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x) return 0;
  y = x->OrganizationUnit;
  if (y)
    x->OrganizationUnit = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_OrganizationUnit) */

void zx_hrxml_SchoolOrInstitution_PUSH_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_OrganizationUnit_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->OrganizationUnit->gg.g;
  x->OrganizationUnit = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_OrganizationUnit) */

void zx_hrxml_SchoolOrInstitution_REV_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_OrganizationUnit_s* nxt;
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x) return;
  y = x->OrganizationUnit;
  if (!y) return;
  x->OrganizationUnit = 0;
  while (y) {
    nxt = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n;
    y->gg.g.n = &x->OrganizationUnit->gg.g;
    x->OrganizationUnit = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_OrganizationUnit) */

void zx_hrxml_SchoolOrInstitution_PUT_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_OrganizationUnit_s* z)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x || !z) return;
  y = x->OrganizationUnit;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->OrganizationUnit = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_OrganizationUnit) */

void zx_hrxml_SchoolOrInstitution_ADD_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_OrganizationUnit_s* z)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->OrganizationUnit->gg.g;
    x->OrganizationUnit = z;
    return;
  case -1:
    y = x->OrganizationUnit;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationUnit; n > 1 && y; --n, y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_OrganizationUnit) */

void zx_hrxml_SchoolOrInstitution_DEL_OrganizationUnit(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_OrganizationUnit_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OrganizationUnit = (struct zx_hrxml_OrganizationUnit_s*)x->OrganizationUnit->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_OrganizationUnit_s*)x->OrganizationUnit;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->OrganizationUnit; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_OrganizationUnit_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_Degree) */

int zx_hrxml_SchoolOrInstitution_NUM_Degree(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Degree_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Degree; y; ++n, y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_Degree) */

struct zx_hrxml_Degree_s* zx_hrxml_SchoolOrInstitution_GET_Degree(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_Degree_s* y;
  if (!x) return 0;
  for (y = x->Degree; n>=0 && y; --n, y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_Degree) */

struct zx_hrxml_Degree_s* zx_hrxml_SchoolOrInstitution_POP_Degree(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Degree_s* y;
  if (!x) return 0;
  y = x->Degree;
  if (y)
    x->Degree = (struct zx_hrxml_Degree_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_Degree) */

void zx_hrxml_SchoolOrInstitution_PUSH_Degree(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_Degree_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Degree->gg.g;
  x->Degree = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_Degree) */

void zx_hrxml_SchoolOrInstitution_REV_Degree(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Degree_s* nxt;
  struct zx_hrxml_Degree_s* y;
  if (!x) return;
  y = x->Degree;
  if (!y) return;
  x->Degree = 0;
  while (y) {
    nxt = (struct zx_hrxml_Degree_s*)y->gg.g.n;
    y->gg.g.n = &x->Degree->gg.g;
    x->Degree = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_Degree) */

void zx_hrxml_SchoolOrInstitution_PUT_Degree(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_Degree_s* z)
{
  struct zx_hrxml_Degree_s* y;
  if (!x || !z) return;
  y = x->Degree;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Degree = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_Degree) */

void zx_hrxml_SchoolOrInstitution_ADD_Degree(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_Degree_s* z)
{
  struct zx_hrxml_Degree_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Degree->gg.g;
    x->Degree = z;
    return;
  case -1:
    y = x->Degree;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Degree; n > 1 && y; --n, y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_Degree) */

void zx_hrxml_SchoolOrInstitution_DEL_Degree(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_Degree_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Degree = (struct zx_hrxml_Degree_s*)x->Degree->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Degree_s*)x->Degree;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Degree; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Degree_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_Major) */

int zx_hrxml_SchoolOrInstitution_NUM_Major(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Major; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_Major) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_GET_Major(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Major; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_Major) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_POP_Major(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Major;
  if (y)
    x->Major = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_Major) */

void zx_hrxml_SchoolOrInstitution_PUSH_Major(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Major->g;
  x->Major = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_Major) */

void zx_hrxml_SchoolOrInstitution_REV_Major(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Major;
  if (!y) return;
  x->Major = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Major->g;
    x->Major = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_Major) */

void zx_hrxml_SchoolOrInstitution_PUT_Major(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Major;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Major = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_Major) */

void zx_hrxml_SchoolOrInstitution_ADD_Major(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Major->g;
    x->Major = z;
    return;
  case -1:
    y = x->Major;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Major; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_Major) */

void zx_hrxml_SchoolOrInstitution_DEL_Major(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Major = (struct zx_elem_s*)x->Major->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Major;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Major; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_Minor) */

int zx_hrxml_SchoolOrInstitution_NUM_Minor(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Minor; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_Minor) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_GET_Minor(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Minor; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_Minor) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_POP_Minor(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Minor;
  if (y)
    x->Minor = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_Minor) */

void zx_hrxml_SchoolOrInstitution_PUSH_Minor(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Minor->g;
  x->Minor = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_Minor) */

void zx_hrxml_SchoolOrInstitution_REV_Minor(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Minor;
  if (!y) return;
  x->Minor = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Minor->g;
    x->Minor = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_Minor) */

void zx_hrxml_SchoolOrInstitution_PUT_Minor(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Minor;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Minor = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_Minor) */

void zx_hrxml_SchoolOrInstitution_ADD_Minor(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Minor->g;
    x->Minor = z;
    return;
  case -1:
    y = x->Minor;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Minor; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_Minor) */

void zx_hrxml_SchoolOrInstitution_DEL_Minor(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Minor = (struct zx_elem_s*)x->Minor->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Minor;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Minor; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_Measure) */

int zx_hrxml_SchoolOrInstitution_NUM_Measure(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Measure_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Measure; y; ++n, y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_Measure) */

struct zx_hrxml_Measure_s* zx_hrxml_SchoolOrInstitution_GET_Measure(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_Measure_s* y;
  if (!x) return 0;
  for (y = x->Measure; n>=0 && y; --n, y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_Measure) */

struct zx_hrxml_Measure_s* zx_hrxml_SchoolOrInstitution_POP_Measure(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Measure_s* y;
  if (!x) return 0;
  y = x->Measure;
  if (y)
    x->Measure = (struct zx_hrxml_Measure_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_Measure) */

void zx_hrxml_SchoolOrInstitution_PUSH_Measure(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_Measure_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Measure->gg.g;
  x->Measure = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_Measure) */

void zx_hrxml_SchoolOrInstitution_REV_Measure(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_Measure_s* nxt;
  struct zx_hrxml_Measure_s* y;
  if (!x) return;
  y = x->Measure;
  if (!y) return;
  x->Measure = 0;
  while (y) {
    nxt = (struct zx_hrxml_Measure_s*)y->gg.g.n;
    y->gg.g.n = &x->Measure->gg.g;
    x->Measure = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_Measure) */

void zx_hrxml_SchoolOrInstitution_PUT_Measure(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_Measure_s* z)
{
  struct zx_hrxml_Measure_s* y;
  if (!x || !z) return;
  y = x->Measure;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Measure = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_Measure) */

void zx_hrxml_SchoolOrInstitution_ADD_Measure(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_Measure_s* z)
{
  struct zx_hrxml_Measure_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Measure->gg.g;
    x->Measure = z;
    return;
  case -1:
    y = x->Measure;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Measure; n > 1 && y; --n, y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_Measure) */

void zx_hrxml_SchoolOrInstitution_DEL_Measure(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_Measure_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Measure = (struct zx_hrxml_Measure_s*)x->Measure->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Measure_s*)x->Measure;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Measure; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Measure_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_DatesOfAttendance) */

int zx_hrxml_SchoolOrInstitution_NUM_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DatesOfAttendance; y; ++n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_DatesOfAttendance) */

struct zx_hrxml_DatesOfAttendance_s* zx_hrxml_SchoolOrInstitution_GET_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return 0;
  for (y = x->DatesOfAttendance; n>=0 && y; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_DatesOfAttendance) */

struct zx_hrxml_DatesOfAttendance_s* zx_hrxml_SchoolOrInstitution_POP_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return 0;
  y = x->DatesOfAttendance;
  if (y)
    x->DatesOfAttendance = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_DatesOfAttendance) */

void zx_hrxml_SchoolOrInstitution_PUSH_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_DatesOfAttendance_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DatesOfAttendance->gg.g;
  x->DatesOfAttendance = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_DatesOfAttendance) */

void zx_hrxml_SchoolOrInstitution_REV_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_DatesOfAttendance_s* nxt;
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return;
  y = x->DatesOfAttendance;
  if (!y) return;
  x->DatesOfAttendance = 0;
  while (y) {
    nxt = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n;
    y->gg.g.n = &x->DatesOfAttendance->gg.g;
    x->DatesOfAttendance = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_DatesOfAttendance) */

void zx_hrxml_SchoolOrInstitution_PUT_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_DatesOfAttendance_s* z)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x || !z) return;
  y = x->DatesOfAttendance;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DatesOfAttendance = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_DatesOfAttendance) */

void zx_hrxml_SchoolOrInstitution_ADD_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_DatesOfAttendance_s* z)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DatesOfAttendance->gg.g;
    x->DatesOfAttendance = z;
    return;
  case -1:
    y = x->DatesOfAttendance;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfAttendance; n > 1 && y; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_DatesOfAttendance) */

void zx_hrxml_SchoolOrInstitution_DEL_DatesOfAttendance(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_DatesOfAttendance_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DatesOfAttendance = (struct zx_hrxml_DatesOfAttendance_s*)x->DatesOfAttendance->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DatesOfAttendance_s*)x->DatesOfAttendance;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfAttendance; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfAttendance_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_Comments) */

int zx_hrxml_SchoolOrInstitution_NUM_Comments(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_Comments) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_GET_Comments(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_Comments) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_POP_Comments(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_Comments) */

void zx_hrxml_SchoolOrInstitution_PUSH_Comments(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_Comments) */

void zx_hrxml_SchoolOrInstitution_REV_Comments(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_Comments) */

void zx_hrxml_SchoolOrInstitution_PUT_Comments(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_Comments) */

void zx_hrxml_SchoolOrInstitution_ADD_Comments(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_Comments) */

void zx_hrxml_SchoolOrInstitution_DEL_Comments(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_ISCEDInstitutionClassification) */

int zx_hrxml_SchoolOrInstitution_NUM_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ISCEDInstitutionClassification; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_ISCEDInstitutionClassification) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_GET_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ISCEDInstitutionClassification; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_ISCEDInstitutionClassification) */

struct zx_elem_s* zx_hrxml_SchoolOrInstitution_POP_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ISCEDInstitutionClassification;
  if (y)
    x->ISCEDInstitutionClassification = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_ISCEDInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_PUSH_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ISCEDInstitutionClassification->g;
  x->ISCEDInstitutionClassification = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_ISCEDInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_REV_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ISCEDInstitutionClassification;
  if (!y) return;
  x->ISCEDInstitutionClassification = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ISCEDInstitutionClassification->g;
    x->ISCEDInstitutionClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_ISCEDInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_PUT_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ISCEDInstitutionClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ISCEDInstitutionClassification = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_ISCEDInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_ADD_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ISCEDInstitutionClassification->g;
    x->ISCEDInstitutionClassification = z;
    return;
  case -1:
    y = x->ISCEDInstitutionClassification;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISCEDInstitutionClassification; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_ISCEDInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_DEL_ISCEDInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ISCEDInstitutionClassification = (struct zx_elem_s*)x->ISCEDInstitutionClassification->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ISCEDInstitutionClassification;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ISCEDInstitutionClassification; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_LocalInstitutionClassification) */

int zx_hrxml_SchoolOrInstitution_NUM_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LocalInstitutionClassification; y; ++n, y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_LocalInstitutionClassification) */

struct zx_hrxml_LocalInstitutionClassification_s* zx_hrxml_SchoolOrInstitution_GET_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x) return 0;
  for (y = x->LocalInstitutionClassification; n>=0 && y; --n, y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_LocalInstitutionClassification) */

struct zx_hrxml_LocalInstitutionClassification_s* zx_hrxml_SchoolOrInstitution_POP_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x) return 0;
  y = x->LocalInstitutionClassification;
  if (y)
    x->LocalInstitutionClassification = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_LocalInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_PUSH_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_LocalInstitutionClassification_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LocalInstitutionClassification->gg.g;
  x->LocalInstitutionClassification = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_LocalInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_REV_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_LocalInstitutionClassification_s* nxt;
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x) return;
  y = x->LocalInstitutionClassification;
  if (!y) return;
  x->LocalInstitutionClassification = 0;
  while (y) {
    nxt = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n;
    y->gg.g.n = &x->LocalInstitutionClassification->gg.g;
    x->LocalInstitutionClassification = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_LocalInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_PUT_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_LocalInstitutionClassification_s* z)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x || !z) return;
  y = x->LocalInstitutionClassification;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LocalInstitutionClassification = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_LocalInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_ADD_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_LocalInstitutionClassification_s* z)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LocalInstitutionClassification->gg.g;
    x->LocalInstitutionClassification = z;
    return;
  case -1:
    y = x->LocalInstitutionClassification;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocalInstitutionClassification; n > 1 && y; --n, y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_LocalInstitutionClassification) */

void zx_hrxml_SchoolOrInstitution_DEL_LocalInstitutionClassification(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_LocalInstitutionClassification_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LocalInstitutionClassification = (struct zx_hrxml_LocalInstitutionClassification_s*)x->LocalInstitutionClassification->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LocalInstitutionClassification_s*)x->LocalInstitutionClassification;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LocalInstitutionClassification; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LocalInstitutionClassification_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SchoolOrInstitution_NUM_UserArea) */

int zx_hrxml_SchoolOrInstitution_NUM_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SchoolOrInstitution_GET_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SchoolOrInstitution_POP_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUSH_UserArea) */

void zx_hrxml_SchoolOrInstitution_PUSH_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_REV_UserArea) */

void zx_hrxml_SchoolOrInstitution_REV_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_UserArea) */

void zx_hrxml_SchoolOrInstitution_PUT_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SchoolOrInstitution_ADD_UserArea) */

void zx_hrxml_SchoolOrInstitution_ADD_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SchoolOrInstitution_DEL_UserArea) */

void zx_hrxml_SchoolOrInstitution_DEL_UserArea(struct zx_hrxml_SchoolOrInstitution_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_SchoolOrInstitution_GET_schoolType) */
struct zx_str* zx_hrxml_SchoolOrInstitution_GET_schoolType(struct zx_hrxml_SchoolOrInstitution_s* x) { return x->schoolType; }
/* FUNC(zx_hrxml_SchoolOrInstitution_PUT_schoolType) */
void zx_hrxml_SchoolOrInstitution_PUT_schoolType(struct zx_hrxml_SchoolOrInstitution_s* x, struct zx_str* y) { x->schoolType = y; }





/* FUNC(zx_hrxml_Score_GET_unitOfMeasure) */
struct zx_str* zx_hrxml_Score_GET_unitOfMeasure(struct zx_hrxml_Score_s* x) { return x->unitOfMeasure; }
/* FUNC(zx_hrxml_Score_PUT_unitOfMeasure) */
void zx_hrxml_Score_PUT_unitOfMeasure(struct zx_hrxml_Score_s* x, struct zx_str* y) { x->unitOfMeasure = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_SearchCriteriaId) */

int zx_hrxml_SearchCriteria_NUM_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchCriteriaId; y; ++n, y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_SearchCriteriaId) */

struct zx_hrxml_SearchCriteriaId_s* zx_hrxml_SearchCriteria_GET_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x) return 0;
  for (y = x->SearchCriteriaId; n>=0 && y; --n, y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_SearchCriteriaId) */

struct zx_hrxml_SearchCriteriaId_s* zx_hrxml_SearchCriteria_POP_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x) return 0;
  y = x->SearchCriteriaId;
  if (y)
    x->SearchCriteriaId = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_SearchCriteriaId) */

void zx_hrxml_SearchCriteria_PUSH_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x, struct zx_hrxml_SearchCriteriaId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchCriteriaId->gg.g;
  x->SearchCriteriaId = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_SearchCriteriaId) */

void zx_hrxml_SearchCriteria_REV_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriteriaId_s* nxt;
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x) return;
  y = x->SearchCriteriaId;
  if (!y) return;
  x->SearchCriteriaId = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchCriteriaId->gg.g;
    x->SearchCriteriaId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_SearchCriteriaId) */

void zx_hrxml_SearchCriteria_PUT_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_SearchCriteriaId_s* z)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x || !z) return;
  y = x->SearchCriteriaId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchCriteriaId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_SearchCriteriaId) */

void zx_hrxml_SearchCriteria_ADD_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_SearchCriteriaId_s* z)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchCriteriaId->gg.g;
    x->SearchCriteriaId = z;
    return;
  case -1:
    y = x->SearchCriteriaId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriteriaId; n > 1 && y; --n, y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_SearchCriteriaId) */

void zx_hrxml_SearchCriteria_DEL_SearchCriteriaId(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_SearchCriteriaId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchCriteriaId = (struct zx_hrxml_SearchCriteriaId_s*)x->SearchCriteriaId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchCriteriaId_s*)x->SearchCriteriaId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriteriaId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriteriaId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_SearchTarget) */

int zx_hrxml_SearchCriteria_NUM_SearchTarget(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchTarget; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_SearchTarget) */

struct zx_elem_s* zx_hrxml_SearchCriteria_GET_SearchTarget(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchTarget; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_SearchTarget) */

struct zx_elem_s* zx_hrxml_SearchCriteria_POP_SearchTarget(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchTarget;
  if (y)
    x->SearchTarget = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_SearchTarget) */

void zx_hrxml_SearchCriteria_PUSH_SearchTarget(struct zx_hrxml_SearchCriteria_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchTarget->g;
  x->SearchTarget = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_SearchTarget) */

void zx_hrxml_SearchCriteria_REV_SearchTarget(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchTarget;
  if (!y) return;
  x->SearchTarget = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchTarget->g;
    x->SearchTarget = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_SearchTarget) */

void zx_hrxml_SearchCriteria_PUT_SearchTarget(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchTarget;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchTarget = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_SearchTarget) */

void zx_hrxml_SearchCriteria_ADD_SearchTarget(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchTarget->g;
    x->SearchTarget = z;
    return;
  case -1:
    y = x->SearchTarget;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTarget; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_SearchTarget) */

void zx_hrxml_SearchCriteria_DEL_SearchTarget(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchTarget = (struct zx_elem_s*)x->SearchTarget->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchTarget;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTarget; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_UserId) */

int zx_hrxml_SearchCriteria_NUM_UserId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserId; y; ++n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_UserId) */

struct zx_hrxml_UserId_s* zx_hrxml_SearchCriteria_GET_UserId(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return 0;
  for (y = x->UserId; n>=0 && y; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_UserId) */

struct zx_hrxml_UserId_s* zx_hrxml_SearchCriteria_POP_UserId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return 0;
  y = x->UserId;
  if (y)
    x->UserId = (struct zx_hrxml_UserId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_UserId) */

void zx_hrxml_SearchCriteria_PUSH_UserId(struct zx_hrxml_SearchCriteria_s* x, struct zx_hrxml_UserId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserId->gg.g;
  x->UserId = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_UserId) */

void zx_hrxml_SearchCriteria_REV_UserId(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserId_s* nxt;
  struct zx_hrxml_UserId_s* y;
  if (!x) return;
  y = x->UserId;
  if (!y) return;
  x->UserId = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserId_s*)y->gg.g.n;
    y->gg.g.n = &x->UserId->gg.g;
    x->UserId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_UserId) */

void zx_hrxml_SearchCriteria_PUT_UserId(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_UserId_s* z)
{
  struct zx_hrxml_UserId_s* y;
  if (!x || !z) return;
  y = x->UserId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_UserId) */

void zx_hrxml_SearchCriteria_ADD_UserId(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_UserId_s* z)
{
  struct zx_hrxml_UserId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserId->gg.g;
    x->UserId = z;
    return;
  case -1:
    y = x->UserId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserId; n > 1 && y; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_UserId) */

void zx_hrxml_SearchCriteria_DEL_UserId(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserId = (struct zx_hrxml_UserId_s*)x->UserId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserId_s*)x->UserId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_SearchTimeStamp) */

int zx_hrxml_SearchCriteria_NUM_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchTimeStamp; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_SearchTimeStamp) */

struct zx_elem_s* zx_hrxml_SearchCriteria_GET_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchTimeStamp; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_SearchTimeStamp) */

struct zx_elem_s* zx_hrxml_SearchCriteria_POP_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchTimeStamp;
  if (y)
    x->SearchTimeStamp = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_SearchTimeStamp) */

void zx_hrxml_SearchCriteria_PUSH_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchTimeStamp->g;
  x->SearchTimeStamp = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_SearchTimeStamp) */

void zx_hrxml_SearchCriteria_REV_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchTimeStamp;
  if (!y) return;
  x->SearchTimeStamp = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchTimeStamp->g;
    x->SearchTimeStamp = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_SearchTimeStamp) */

void zx_hrxml_SearchCriteria_PUT_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchTimeStamp;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchTimeStamp = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_SearchTimeStamp) */

void zx_hrxml_SearchCriteria_ADD_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchTimeStamp->g;
    x->SearchTimeStamp = z;
    return;
  case -1:
    y = x->SearchTimeStamp;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTimeStamp; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_SearchTimeStamp) */

void zx_hrxml_SearchCriteria_DEL_SearchTimeStamp(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchTimeStamp = (struct zx_elem_s*)x->SearchTimeStamp->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchTimeStamp;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTimeStamp; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_SearchString) */

int zx_hrxml_SearchCriteria_NUM_SearchString(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchString; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_SearchString) */

struct zx_elem_s* zx_hrxml_SearchCriteria_GET_SearchString(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchString; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_SearchString) */

struct zx_elem_s* zx_hrxml_SearchCriteria_POP_SearchString(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchString;
  if (y)
    x->SearchString = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_SearchString) */

void zx_hrxml_SearchCriteria_PUSH_SearchString(struct zx_hrxml_SearchCriteria_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchString->g;
  x->SearchString = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_SearchString) */

void zx_hrxml_SearchCriteria_REV_SearchString(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchString;
  if (!y) return;
  x->SearchString = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchString->g;
    x->SearchString = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_SearchString) */

void zx_hrxml_SearchCriteria_PUT_SearchString(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchString;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchString = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_SearchString) */

void zx_hrxml_SearchCriteria_ADD_SearchString(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchString->g;
    x->SearchString = z;
    return;
  case -1:
    y = x->SearchString;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchString; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_SearchString) */

void zx_hrxml_SearchCriteria_DEL_SearchString(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchString = (struct zx_elem_s*)x->SearchString->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchString;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchString; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_SearchCriterion) */

int zx_hrxml_SearchCriteria_NUM_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriterion_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchCriterion; y; ++n, y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_SearchCriterion) */

struct zx_hrxml_SearchCriterion_s* zx_hrxml_SearchCriteria_GET_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x) return 0;
  for (y = x->SearchCriterion; n>=0 && y; --n, y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_SearchCriterion) */

struct zx_hrxml_SearchCriterion_s* zx_hrxml_SearchCriteria_POP_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x) return 0;
  y = x->SearchCriterion;
  if (y)
    x->SearchCriterion = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_SearchCriterion) */

void zx_hrxml_SearchCriteria_PUSH_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x, struct zx_hrxml_SearchCriterion_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchCriterion->gg.g;
  x->SearchCriterion = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_SearchCriterion) */

void zx_hrxml_SearchCriteria_REV_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_SearchCriterion_s* nxt;
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x) return;
  y = x->SearchCriterion;
  if (!y) return;
  x->SearchCriterion = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchCriterion->gg.g;
    x->SearchCriterion = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_SearchCriterion) */

void zx_hrxml_SearchCriteria_PUT_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_SearchCriterion_s* z)
{
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x || !z) return;
  y = x->SearchCriterion;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchCriterion = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_SearchCriterion) */

void zx_hrxml_SearchCriteria_ADD_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_SearchCriterion_s* z)
{
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchCriterion->gg.g;
    x->SearchCriterion = z;
    return;
  case -1:
    y = x->SearchCriterion;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriterion; n > 1 && y; --n, y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_SearchCriterion) */

void zx_hrxml_SearchCriteria_DEL_SearchCriterion(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_SearchCriterion_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchCriterion = (struct zx_hrxml_SearchCriterion_s*)x->SearchCriterion->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchCriterion_s*)x->SearchCriterion;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchCriterion; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchCriterion_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteria_NUM_UserArea) */

int zx_hrxml_SearchCriteria_NUM_UserArea(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteria_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SearchCriteria_GET_UserArea(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SearchCriteria_POP_UserArea(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteria_PUSH_UserArea) */

void zx_hrxml_SearchCriteria_PUSH_UserArea(struct zx_hrxml_SearchCriteria_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_SearchCriteria_REV_UserArea) */

void zx_hrxml_SearchCriteria_REV_UserArea(struct zx_hrxml_SearchCriteria_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_PUT_UserArea) */

void zx_hrxml_SearchCriteria_PUT_UserArea(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriteria_ADD_UserArea) */

void zx_hrxml_SearchCriteria_ADD_UserArea(struct zx_hrxml_SearchCriteria_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriteria_DEL_UserArea) */

void zx_hrxml_SearchCriteria_DEL_UserArea(struct zx_hrxml_SearchCriteria_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriteriaId_NUM_IdValue) */

int zx_hrxml_SearchCriteriaId_NUM_IdValue(struct zx_hrxml_SearchCriteriaId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriteriaId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SearchCriteriaId_GET_IdValue(struct zx_hrxml_SearchCriteriaId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteriaId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SearchCriteriaId_POP_IdValue(struct zx_hrxml_SearchCriteriaId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriteriaId_PUSH_IdValue) */

void zx_hrxml_SearchCriteriaId_PUSH_IdValue(struct zx_hrxml_SearchCriteriaId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_SearchCriteriaId_REV_IdValue) */

void zx_hrxml_SearchCriteriaId_REV_IdValue(struct zx_hrxml_SearchCriteriaId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriteriaId_PUT_IdValue) */

void zx_hrxml_SearchCriteriaId_PUT_IdValue(struct zx_hrxml_SearchCriteriaId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriteriaId_ADD_IdValue) */

void zx_hrxml_SearchCriteriaId_ADD_IdValue(struct zx_hrxml_SearchCriteriaId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriteriaId_DEL_IdValue) */

void zx_hrxml_SearchCriteriaId_DEL_IdValue(struct zx_hrxml_SearchCriteriaId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_SearchCriteriaId_GET_idOwner) */
struct zx_str* zx_hrxml_SearchCriteriaId_GET_idOwner(struct zx_hrxml_SearchCriteriaId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_SearchCriteriaId_PUT_idOwner) */
void zx_hrxml_SearchCriteriaId_PUT_idOwner(struct zx_hrxml_SearchCriteriaId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_SearchCriteriaId_GET_validFrom) */
struct zx_str* zx_hrxml_SearchCriteriaId_GET_validFrom(struct zx_hrxml_SearchCriteriaId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_SearchCriteriaId_PUT_validFrom) */
void zx_hrxml_SearchCriteriaId_PUT_validFrom(struct zx_hrxml_SearchCriteriaId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_SearchCriteriaId_GET_validTo) */
struct zx_str* zx_hrxml_SearchCriteriaId_GET_validTo(struct zx_hrxml_SearchCriteriaId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_SearchCriteriaId_PUT_validTo) */
void zx_hrxml_SearchCriteriaId_PUT_validTo(struct zx_hrxml_SearchCriteriaId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriterion_NUM_CriterionName) */

int zx_hrxml_SearchCriterion_NUM_CriterionName(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CriterionName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriterion_GET_CriterionName) */

struct zx_elem_s* zx_hrxml_SearchCriterion_GET_CriterionName(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CriterionName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_POP_CriterionName) */

struct zx_elem_s* zx_hrxml_SearchCriterion_POP_CriterionName(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CriterionName;
  if (y)
    x->CriterionName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_PUSH_CriterionName) */

void zx_hrxml_SearchCriterion_PUSH_CriterionName(struct zx_hrxml_SearchCriterion_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CriterionName->g;
  x->CriterionName = z;
}

/* FUNC(zx_hrxml_SearchCriterion_REV_CriterionName) */

void zx_hrxml_SearchCriterion_REV_CriterionName(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CriterionName;
  if (!y) return;
  x->CriterionName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CriterionName->g;
    x->CriterionName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_PUT_CriterionName) */

void zx_hrxml_SearchCriterion_PUT_CriterionName(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CriterionName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CriterionName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_ADD_CriterionName) */

void zx_hrxml_SearchCriterion_ADD_CriterionName(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CriterionName->g;
    x->CriterionName = z;
    return;
  case -1:
    y = x->CriterionName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchCriterion_DEL_CriterionName) */

void zx_hrxml_SearchCriterion_DEL_CriterionName(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CriterionName = (struct zx_elem_s*)x->CriterionName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CriterionName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriterion_NUM_CriterionValue) */

int zx_hrxml_SearchCriterion_NUM_CriterionValue(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CriterionValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriterion_GET_CriterionValue) */

struct zx_elem_s* zx_hrxml_SearchCriterion_GET_CriterionValue(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->CriterionValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_POP_CriterionValue) */

struct zx_elem_s* zx_hrxml_SearchCriterion_POP_CriterionValue(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->CriterionValue;
  if (y)
    x->CriterionValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_PUSH_CriterionValue) */

void zx_hrxml_SearchCriterion_PUSH_CriterionValue(struct zx_hrxml_SearchCriterion_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->CriterionValue->g;
  x->CriterionValue = z;
}

/* FUNC(zx_hrxml_SearchCriterion_REV_CriterionValue) */

void zx_hrxml_SearchCriterion_REV_CriterionValue(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->CriterionValue;
  if (!y) return;
  x->CriterionValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->CriterionValue->g;
    x->CriterionValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_PUT_CriterionValue) */

void zx_hrxml_SearchCriterion_PUT_CriterionValue(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->CriterionValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->CriterionValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_ADD_CriterionValue) */

void zx_hrxml_SearchCriterion_ADD_CriterionValue(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->CriterionValue->g;
    x->CriterionValue = z;
    return;
  case -1:
    y = x->CriterionValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchCriterion_DEL_CriterionValue) */

void zx_hrxml_SearchCriterion_DEL_CriterionValue(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CriterionValue = (struct zx_elem_s*)x->CriterionValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->CriterionValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->CriterionValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchCriterion_NUM_Weight) */

int zx_hrxml_SearchCriterion_NUM_Weight(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_hrxml_Weight_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Weight; y; ++n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchCriterion_GET_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_SearchCriterion_GET_Weight(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  for (y = x->Weight; n>=0 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_POP_Weight) */

struct zx_hrxml_Weight_s* zx_hrxml_SearchCriterion_POP_Weight(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return 0;
  y = x->Weight;
  if (y)
    x->Weight = (struct zx_hrxml_Weight_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchCriterion_PUSH_Weight) */

void zx_hrxml_SearchCriterion_PUSH_Weight(struct zx_hrxml_SearchCriterion_s* x, struct zx_hrxml_Weight_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Weight->gg.g;
  x->Weight = z;
}

/* FUNC(zx_hrxml_SearchCriterion_REV_Weight) */

void zx_hrxml_SearchCriterion_REV_Weight(struct zx_hrxml_SearchCriterion_s* x)
{
  struct zx_hrxml_Weight_s* nxt;
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  y = x->Weight;
  if (!y) return;
  x->Weight = 0;
  while (y) {
    nxt = (struct zx_hrxml_Weight_s*)y->gg.g.n;
    y->gg.g.n = &x->Weight->gg.g;
    x->Weight = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_PUT_Weight) */

void zx_hrxml_SearchCriterion_PUT_Weight(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  y = x->Weight;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Weight = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchCriterion_ADD_Weight) */

void zx_hrxml_SearchCriterion_ADD_Weight(struct zx_hrxml_SearchCriterion_s* x, int n, struct zx_hrxml_Weight_s* z)
{
  struct zx_hrxml_Weight_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Weight->gg.g;
    x->Weight = z;
    return;
  case -1:
    y = x->Weight;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchCriterion_DEL_Weight) */

void zx_hrxml_SearchCriterion_DEL_Weight(struct zx_hrxml_SearchCriterion_s* x, int n)
{
  struct zx_hrxml_Weight_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Weight = (struct zx_hrxml_Weight_s*)x->Weight->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Weight_s*)x->Weight;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Weight; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Weight_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif






/* FUNC(zx_hrxml_SearchRelevanceScore_GET_unitOfMeasure) */
struct zx_str* zx_hrxml_SearchRelevanceScore_GET_unitOfMeasure(struct zx_hrxml_SearchRelevanceScore_s* x) { return x->unitOfMeasure; }
/* FUNC(zx_hrxml_SearchRelevanceScore_PUT_unitOfMeasure) */
void zx_hrxml_SearchRelevanceScore_PUT_unitOfMeasure(struct zx_hrxml_SearchRelevanceScore_s* x, struct zx_str* y) { x->unitOfMeasure = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchResultId) */

int zx_hrxml_SearchResult_NUM_SearchResultId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchResultId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchResultId; y; ++n, y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchResultId) */

struct zx_hrxml_SearchResultId_s* zx_hrxml_SearchResult_GET_SearchResultId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_SearchResultId_s* y;
  if (!x) return 0;
  for (y = x->SearchResultId; n>=0 && y; --n, y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchResultId) */

struct zx_hrxml_SearchResultId_s* zx_hrxml_SearchResult_POP_SearchResultId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchResultId_s* y;
  if (!x) return 0;
  y = x->SearchResultId;
  if (y)
    x->SearchResultId = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchResultId) */

void zx_hrxml_SearchResult_PUSH_SearchResultId(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_SearchResultId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchResultId->gg.g;
  x->SearchResultId = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchResultId) */

void zx_hrxml_SearchResult_REV_SearchResultId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchResultId_s* nxt;
  struct zx_hrxml_SearchResultId_s* y;
  if (!x) return;
  y = x->SearchResultId;
  if (!y) return;
  x->SearchResultId = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchResultId->gg.g;
    x->SearchResultId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchResultId) */

void zx_hrxml_SearchResult_PUT_SearchResultId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_SearchResultId_s* z)
{
  struct zx_hrxml_SearchResultId_s* y;
  if (!x || !z) return;
  y = x->SearchResultId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchResultId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchResultId) */

void zx_hrxml_SearchResult_ADD_SearchResultId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_SearchResultId_s* z)
{
  struct zx_hrxml_SearchResultId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchResultId->gg.g;
    x->SearchResultId = z;
    return;
  case -1:
    y = x->SearchResultId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchResultId; n > 1 && y; --n, y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchResultId) */

void zx_hrxml_SearchResult_DEL_SearchResultId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_SearchResultId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchResultId = (struct zx_hrxml_SearchResultId_s*)x->SearchResultId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchResultId_s*)x->SearchResultId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchResultId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchResultId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchTarget) */

int zx_hrxml_SearchResult_NUM_SearchTarget(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchTarget; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchTarget) */

struct zx_elem_s* zx_hrxml_SearchResult_GET_SearchTarget(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchTarget; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchTarget) */

struct zx_elem_s* zx_hrxml_SearchResult_POP_SearchTarget(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchTarget;
  if (y)
    x->SearchTarget = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchTarget) */

void zx_hrxml_SearchResult_PUSH_SearchTarget(struct zx_hrxml_SearchResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchTarget->g;
  x->SearchTarget = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchTarget) */

void zx_hrxml_SearchResult_REV_SearchTarget(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchTarget;
  if (!y) return;
  x->SearchTarget = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchTarget->g;
    x->SearchTarget = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchTarget) */

void zx_hrxml_SearchResult_PUT_SearchTarget(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchTarget;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchTarget = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchTarget) */

void zx_hrxml_SearchResult_ADD_SearchTarget(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchTarget->g;
    x->SearchTarget = z;
    return;
  case -1:
    y = x->SearchTarget;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTarget; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchTarget) */

void zx_hrxml_SearchResult_DEL_SearchTarget(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchTarget = (struct zx_elem_s*)x->SearchTarget->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchTarget;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTarget; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_UserId) */

int zx_hrxml_SearchResult_NUM_UserId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserId; y; ++n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_UserId) */

struct zx_hrxml_UserId_s* zx_hrxml_SearchResult_GET_UserId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return 0;
  for (y = x->UserId; n>=0 && y; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_UserId) */

struct zx_hrxml_UserId_s* zx_hrxml_SearchResult_POP_UserId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return 0;
  y = x->UserId;
  if (y)
    x->UserId = (struct zx_hrxml_UserId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_UserId) */

void zx_hrxml_SearchResult_PUSH_UserId(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_UserId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserId->gg.g;
  x->UserId = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_UserId) */

void zx_hrxml_SearchResult_REV_UserId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserId_s* nxt;
  struct zx_hrxml_UserId_s* y;
  if (!x) return;
  y = x->UserId;
  if (!y) return;
  x->UserId = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserId_s*)y->gg.g.n;
    y->gg.g.n = &x->UserId->gg.g;
    x->UserId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_UserId) */

void zx_hrxml_SearchResult_PUT_UserId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_UserId_s* z)
{
  struct zx_hrxml_UserId_s* y;
  if (!x || !z) return;
  y = x->UserId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_UserId) */

void zx_hrxml_SearchResult_ADD_UserId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_UserId_s* z)
{
  struct zx_hrxml_UserId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserId->gg.g;
    x->UserId = z;
    return;
  case -1:
    y = x->UserId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserId; n > 1 && y; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_UserId) */

void zx_hrxml_SearchResult_DEL_UserId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_UserId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserId = (struct zx_hrxml_UserId_s*)x->UserId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserId_s*)x->UserId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchTimeStamp) */

int zx_hrxml_SearchResult_NUM_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchTimeStamp; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchTimeStamp) */

struct zx_elem_s* zx_hrxml_SearchResult_GET_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchTimeStamp; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchTimeStamp) */

struct zx_elem_s* zx_hrxml_SearchResult_POP_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchTimeStamp;
  if (y)
    x->SearchTimeStamp = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchTimeStamp) */

void zx_hrxml_SearchResult_PUSH_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchTimeStamp->g;
  x->SearchTimeStamp = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchTimeStamp) */

void zx_hrxml_SearchResult_REV_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchTimeStamp;
  if (!y) return;
  x->SearchTimeStamp = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchTimeStamp->g;
    x->SearchTimeStamp = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchTimeStamp) */

void zx_hrxml_SearchResult_PUT_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchTimeStamp;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchTimeStamp = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchTimeStamp) */

void zx_hrxml_SearchResult_ADD_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchTimeStamp->g;
    x->SearchTimeStamp = z;
    return;
  case -1:
    y = x->SearchTimeStamp;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTimeStamp; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchTimeStamp) */

void zx_hrxml_SearchResult_DEL_SearchTimeStamp(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchTimeStamp = (struct zx_elem_s*)x->SearchTimeStamp->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchTimeStamp;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchTimeStamp; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_MatchedObjectId) */

int zx_hrxml_SearchResult_NUM_MatchedObjectId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MatchedObjectId; y; ++n, y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_MatchedObjectId) */

struct zx_hrxml_MatchedObjectId_s* zx_hrxml_SearchResult_GET_MatchedObjectId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x) return 0;
  for (y = x->MatchedObjectId; n>=0 && y; --n, y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_MatchedObjectId) */

struct zx_hrxml_MatchedObjectId_s* zx_hrxml_SearchResult_POP_MatchedObjectId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x) return 0;
  y = x->MatchedObjectId;
  if (y)
    x->MatchedObjectId = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_MatchedObjectId) */

void zx_hrxml_SearchResult_PUSH_MatchedObjectId(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_MatchedObjectId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->MatchedObjectId->gg.g;
  x->MatchedObjectId = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_MatchedObjectId) */

void zx_hrxml_SearchResult_REV_MatchedObjectId(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_MatchedObjectId_s* nxt;
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x) return;
  y = x->MatchedObjectId;
  if (!y) return;
  x->MatchedObjectId = 0;
  while (y) {
    nxt = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n;
    y->gg.g.n = &x->MatchedObjectId->gg.g;
    x->MatchedObjectId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_MatchedObjectId) */

void zx_hrxml_SearchResult_PUT_MatchedObjectId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_MatchedObjectId_s* z)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x || !z) return;
  y = x->MatchedObjectId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->MatchedObjectId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_MatchedObjectId) */

void zx_hrxml_SearchResult_ADD_MatchedObjectId(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_MatchedObjectId_s* z)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->MatchedObjectId->gg.g;
    x->MatchedObjectId = z;
    return;
  case -1:
    y = x->MatchedObjectId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MatchedObjectId; n > 1 && y; --n, y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_MatchedObjectId) */

void zx_hrxml_SearchResult_DEL_MatchedObjectId(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_MatchedObjectId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MatchedObjectId = (struct zx_hrxml_MatchedObjectId_s*)x->MatchedObjectId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_MatchedObjectId_s*)x->MatchedObjectId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MatchedObjectId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MatchedObjectId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchRelevanceScore) */

int zx_hrxml_SearchResult_NUM_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchRelevanceScore; y; ++n, y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchRelevanceScore) */

struct zx_hrxml_SearchRelevanceScore_s* zx_hrxml_SearchResult_GET_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x) return 0;
  for (y = x->SearchRelevanceScore; n>=0 && y; --n, y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchRelevanceScore) */

struct zx_hrxml_SearchRelevanceScore_s* zx_hrxml_SearchResult_POP_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x) return 0;
  y = x->SearchRelevanceScore;
  if (y)
    x->SearchRelevanceScore = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchRelevanceScore) */

void zx_hrxml_SearchResult_PUSH_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_SearchRelevanceScore_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SearchRelevanceScore->gg.g;
  x->SearchRelevanceScore = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchRelevanceScore) */

void zx_hrxml_SearchResult_REV_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_SearchRelevanceScore_s* nxt;
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x) return;
  y = x->SearchRelevanceScore;
  if (!y) return;
  x->SearchRelevanceScore = 0;
  while (y) {
    nxt = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n;
    y->gg.g.n = &x->SearchRelevanceScore->gg.g;
    x->SearchRelevanceScore = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchRelevanceScore) */

void zx_hrxml_SearchResult_PUT_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_SearchRelevanceScore_s* z)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x || !z) return;
  y = x->SearchRelevanceScore;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SearchRelevanceScore = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchRelevanceScore) */

void zx_hrxml_SearchResult_ADD_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_SearchRelevanceScore_s* z)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SearchRelevanceScore->gg.g;
    x->SearchRelevanceScore = z;
    return;
  case -1:
    y = x->SearchRelevanceScore;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchRelevanceScore; n > 1 && y; --n, y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchRelevanceScore) */

void zx_hrxml_SearchResult_DEL_SearchRelevanceScore(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_SearchRelevanceScore_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchRelevanceScore = (struct zx_hrxml_SearchRelevanceScore_s*)x->SearchRelevanceScore->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SearchRelevanceScore_s*)x->SearchRelevanceScore;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SearchRelevanceScore; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SearchRelevanceScore_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchRelevanceRank) */

int zx_hrxml_SearchResult_NUM_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchRelevanceRank; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchRelevanceRank) */

struct zx_elem_s* zx_hrxml_SearchResult_GET_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchRelevanceRank; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchRelevanceRank) */

struct zx_elem_s* zx_hrxml_SearchResult_POP_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchRelevanceRank;
  if (y)
    x->SearchRelevanceRank = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchRelevanceRank) */

void zx_hrxml_SearchResult_PUSH_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchRelevanceRank->g;
  x->SearchRelevanceRank = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchRelevanceRank) */

void zx_hrxml_SearchResult_REV_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchRelevanceRank;
  if (!y) return;
  x->SearchRelevanceRank = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchRelevanceRank->g;
    x->SearchRelevanceRank = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchRelevanceRank) */

void zx_hrxml_SearchResult_PUT_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchRelevanceRank;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchRelevanceRank = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchRelevanceRank) */

void zx_hrxml_SearchResult_ADD_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchRelevanceRank->g;
    x->SearchRelevanceRank = z;
    return;
  case -1:
    y = x->SearchRelevanceRank;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchRelevanceRank; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchRelevanceRank) */

void zx_hrxml_SearchResult_DEL_SearchRelevanceRank(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchRelevanceRank = (struct zx_elem_s*)x->SearchRelevanceRank->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchRelevanceRank;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchRelevanceRank; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_SearchResultCount) */

int zx_hrxml_SearchResult_NUM_SearchResultCount(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SearchResultCount; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_SearchResultCount) */

struct zx_elem_s* zx_hrxml_SearchResult_GET_SearchResultCount(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->SearchResultCount; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_SearchResultCount) */

struct zx_elem_s* zx_hrxml_SearchResult_POP_SearchResultCount(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->SearchResultCount;
  if (y)
    x->SearchResultCount = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_SearchResultCount) */

void zx_hrxml_SearchResult_PUSH_SearchResultCount(struct zx_hrxml_SearchResult_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->SearchResultCount->g;
  x->SearchResultCount = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_SearchResultCount) */

void zx_hrxml_SearchResult_REV_SearchResultCount(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->SearchResultCount;
  if (!y) return;
  x->SearchResultCount = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->SearchResultCount->g;
    x->SearchResultCount = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_SearchResultCount) */

void zx_hrxml_SearchResult_PUT_SearchResultCount(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->SearchResultCount;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->SearchResultCount = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_SearchResultCount) */

void zx_hrxml_SearchResult_ADD_SearchResultCount(struct zx_hrxml_SearchResult_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->SearchResultCount->g;
    x->SearchResultCount = z;
    return;
  case -1:
    y = x->SearchResultCount;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchResultCount; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_SearchResultCount) */

void zx_hrxml_SearchResult_DEL_SearchResultCount(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SearchResultCount = (struct zx_elem_s*)x->SearchResultCount->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->SearchResultCount;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->SearchResultCount; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_RankedSearchResults) */

int zx_hrxml_SearchResult_NUM_RankedSearchResults(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RankedSearchResults; y; ++n, y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_RankedSearchResults) */

struct zx_hrxml_RankedSearchResults_s* zx_hrxml_SearchResult_GET_RankedSearchResults(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x) return 0;
  for (y = x->RankedSearchResults; n>=0 && y; --n, y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_RankedSearchResults) */

struct zx_hrxml_RankedSearchResults_s* zx_hrxml_SearchResult_POP_RankedSearchResults(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x) return 0;
  y = x->RankedSearchResults;
  if (y)
    x->RankedSearchResults = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_RankedSearchResults) */

void zx_hrxml_SearchResult_PUSH_RankedSearchResults(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_RankedSearchResults_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RankedSearchResults->gg.g;
  x->RankedSearchResults = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_RankedSearchResults) */

void zx_hrxml_SearchResult_REV_RankedSearchResults(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_RankedSearchResults_s* nxt;
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x) return;
  y = x->RankedSearchResults;
  if (!y) return;
  x->RankedSearchResults = 0;
  while (y) {
    nxt = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n;
    y->gg.g.n = &x->RankedSearchResults->gg.g;
    x->RankedSearchResults = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_RankedSearchResults) */

void zx_hrxml_SearchResult_PUT_RankedSearchResults(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_RankedSearchResults_s* z)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x || !z) return;
  y = x->RankedSearchResults;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RankedSearchResults = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_RankedSearchResults) */

void zx_hrxml_SearchResult_ADD_RankedSearchResults(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_RankedSearchResults_s* z)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RankedSearchResults->gg.g;
    x->RankedSearchResults = z;
    return;
  case -1:
    y = x->RankedSearchResults;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedSearchResults; n > 1 && y; --n, y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_RankedSearchResults) */

void zx_hrxml_SearchResult_DEL_RankedSearchResults(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_RankedSearchResults_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RankedSearchResults = (struct zx_hrxml_RankedSearchResults_s*)x->RankedSearchResults->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RankedSearchResults_s*)x->RankedSearchResults;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankedSearchResults; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankedSearchResults_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResult_NUM_UserArea) */

int zx_hrxml_SearchResult_NUM_UserArea(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResult_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SearchResult_GET_UserArea(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_SearchResult_POP_UserArea(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResult_PUSH_UserArea) */

void zx_hrxml_SearchResult_PUSH_UserArea(struct zx_hrxml_SearchResult_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_SearchResult_REV_UserArea) */

void zx_hrxml_SearchResult_REV_UserArea(struct zx_hrxml_SearchResult_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResult_PUT_UserArea) */

void zx_hrxml_SearchResult_PUT_UserArea(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResult_ADD_UserArea) */

void zx_hrxml_SearchResult_ADD_UserArea(struct zx_hrxml_SearchResult_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResult_DEL_UserArea) */

void zx_hrxml_SearchResult_DEL_UserArea(struct zx_hrxml_SearchResult_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SearchResultId_NUM_IdValue) */

int zx_hrxml_SearchResultId_NUM_IdValue(struct zx_hrxml_SearchResultId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SearchResultId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SearchResultId_GET_IdValue(struct zx_hrxml_SearchResultId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SearchResultId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SearchResultId_POP_IdValue(struct zx_hrxml_SearchResultId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SearchResultId_PUSH_IdValue) */

void zx_hrxml_SearchResultId_PUSH_IdValue(struct zx_hrxml_SearchResultId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_SearchResultId_REV_IdValue) */

void zx_hrxml_SearchResultId_REV_IdValue(struct zx_hrxml_SearchResultId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SearchResultId_PUT_IdValue) */

void zx_hrxml_SearchResultId_PUT_IdValue(struct zx_hrxml_SearchResultId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SearchResultId_ADD_IdValue) */

void zx_hrxml_SearchResultId_ADD_IdValue(struct zx_hrxml_SearchResultId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SearchResultId_DEL_IdValue) */

void zx_hrxml_SearchResultId_DEL_IdValue(struct zx_hrxml_SearchResultId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_SearchResultId_GET_idOwner) */
struct zx_str* zx_hrxml_SearchResultId_GET_idOwner(struct zx_hrxml_SearchResultId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_SearchResultId_PUT_idOwner) */
void zx_hrxml_SearchResultId_PUT_idOwner(struct zx_hrxml_SearchResultId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_SearchResultId_GET_validFrom) */
struct zx_str* zx_hrxml_SearchResultId_GET_validFrom(struct zx_hrxml_SearchResultId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_SearchResultId_PUT_validFrom) */
void zx_hrxml_SearchResultId_PUT_validFrom(struct zx_hrxml_SearchResultId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_SearchResultId_GET_validTo) */
struct zx_str* zx_hrxml_SearchResultId_GET_validTo(struct zx_hrxml_SearchResultId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_SearchResultId_PUT_validTo) */
void zx_hrxml_SearchResultId_PUT_validTo(struct zx_hrxml_SearchResultId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredential_NUM_Name) */

int zx_hrxml_SecurityCredential_NUM_Name(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredential_GET_Name) */

struct zx_elem_s* zx_hrxml_SecurityCredential_GET_Name(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_POP_Name) */

struct zx_elem_s* zx_hrxml_SecurityCredential_POP_Name(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_PUSH_Name) */

void zx_hrxml_SecurityCredential_PUSH_Name(struct zx_hrxml_SecurityCredential_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_SecurityCredential_REV_Name) */

void zx_hrxml_SecurityCredential_REV_Name(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_PUT_Name) */

void zx_hrxml_SecurityCredential_PUT_Name(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_ADD_Name) */

void zx_hrxml_SecurityCredential_ADD_Name(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SecurityCredential_DEL_Name) */

void zx_hrxml_SecurityCredential_DEL_Name(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredential_NUM_Id) */

int zx_hrxml_SecurityCredential_NUM_Id(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredential_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_SecurityCredential_GET_Id(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_SecurityCredential_POP_Id(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_PUSH_Id) */

void zx_hrxml_SecurityCredential_PUSH_Id(struct zx_hrxml_SecurityCredential_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_SecurityCredential_REV_Id) */

void zx_hrxml_SecurityCredential_REV_Id(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_PUT_Id) */

void zx_hrxml_SecurityCredential_PUT_Id(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_ADD_Id) */

void zx_hrxml_SecurityCredential_ADD_Id(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SecurityCredential_DEL_Id) */

void zx_hrxml_SecurityCredential_DEL_Id(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredential_NUM_IssuingAuthority) */

int zx_hrxml_SecurityCredential_NUM_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IssuingAuthority; y; ++n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredential_GET_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_SecurityCredential_GET_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  for (y = x->IssuingAuthority; n>=0 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_POP_IssuingAuthority) */

struct zx_hrxml_IssuingAuthority_s* zx_hrxml_SecurityCredential_POP_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return 0;
  y = x->IssuingAuthority;
  if (y)
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_PUSH_IssuingAuthority) */

void zx_hrxml_SecurityCredential_PUSH_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x, struct zx_hrxml_IssuingAuthority_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IssuingAuthority->gg.g;
  x->IssuingAuthority = z;
}

/* FUNC(zx_hrxml_SecurityCredential_REV_IssuingAuthority) */

void zx_hrxml_SecurityCredential_REV_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_IssuingAuthority_s* nxt;
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  y = x->IssuingAuthority;
  if (!y) return;
  x->IssuingAuthority = 0;
  while (y) {
    nxt = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n;
    y->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_PUT_IssuingAuthority) */

void zx_hrxml_SecurityCredential_PUT_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  y = x->IssuingAuthority;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IssuingAuthority = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_ADD_IssuingAuthority) */

void zx_hrxml_SecurityCredential_ADD_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_IssuingAuthority_s* z)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IssuingAuthority->gg.g;
    x->IssuingAuthority = z;
    return;
  case -1:
    y = x->IssuingAuthority;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SecurityCredential_DEL_IssuingAuthority) */

void zx_hrxml_SecurityCredential_DEL_IssuingAuthority(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_IssuingAuthority_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IssuingAuthority = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IssuingAuthority_s*)x->IssuingAuthority;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IssuingAuthority; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IssuingAuthority_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredential_NUM_Description) */

int zx_hrxml_SecurityCredential_NUM_Description(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredential_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SecurityCredential_GET_Description(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SecurityCredential_POP_Description(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_PUSH_Description) */

void zx_hrxml_SecurityCredential_PUSH_Description(struct zx_hrxml_SecurityCredential_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_SecurityCredential_REV_Description) */

void zx_hrxml_SecurityCredential_REV_Description(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_PUT_Description) */

void zx_hrxml_SecurityCredential_PUT_Description(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_ADD_Description) */

void zx_hrxml_SecurityCredential_ADD_Description(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SecurityCredential_DEL_Description) */

void zx_hrxml_SecurityCredential_DEL_Description(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredential_NUM_EffectiveDate) */

int zx_hrxml_SecurityCredential_NUM_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EffectiveDate; y; ++n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredential_GET_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_SecurityCredential_GET_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  for (y = x->EffectiveDate; n>=0 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_POP_EffectiveDate) */

struct zx_hrxml_EffectiveDate_s* zx_hrxml_SecurityCredential_POP_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return 0;
  y = x->EffectiveDate;
  if (y)
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredential_PUSH_EffectiveDate) */

void zx_hrxml_SecurityCredential_PUSH_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x, struct zx_hrxml_EffectiveDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EffectiveDate->gg.g;
  x->EffectiveDate = z;
}

/* FUNC(zx_hrxml_SecurityCredential_REV_EffectiveDate) */

void zx_hrxml_SecurityCredential_REV_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x)
{
  struct zx_hrxml_EffectiveDate_s* nxt;
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  y = x->EffectiveDate;
  if (!y) return;
  x->EffectiveDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_PUT_EffectiveDate) */

void zx_hrxml_SecurityCredential_PUT_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  y = x->EffectiveDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EffectiveDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SecurityCredential_ADD_EffectiveDate) */

void zx_hrxml_SecurityCredential_ADD_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x, int n, struct zx_hrxml_EffectiveDate_s* z)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EffectiveDate->gg.g;
    x->EffectiveDate = z;
    return;
  case -1:
    y = x->EffectiveDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SecurityCredential_DEL_EffectiveDate) */

void zx_hrxml_SecurityCredential_DEL_EffectiveDate(struct zx_hrxml_SecurityCredential_s* x, int n)
{
  struct zx_hrxml_EffectiveDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EffectiveDate = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EffectiveDate_s*)x->EffectiveDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EffectiveDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EffectiveDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SecurityCredentials_NUM_SecurityCredential) */

int zx_hrxml_SecurityCredentials_NUM_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x)
{
  struct zx_hrxml_SecurityCredential_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SecurityCredential; y; ++n, y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SecurityCredentials_GET_SecurityCredential) */

struct zx_hrxml_SecurityCredential_s* zx_hrxml_SecurityCredentials_GET_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x, int n)
{
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x) return 0;
  for (y = x->SecurityCredential; n>=0 && y; --n, y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredentials_POP_SecurityCredential) */

struct zx_hrxml_SecurityCredential_s* zx_hrxml_SecurityCredentials_POP_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x)
{
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x) return 0;
  y = x->SecurityCredential;
  if (y)
    x->SecurityCredential = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SecurityCredentials_PUSH_SecurityCredential) */

void zx_hrxml_SecurityCredentials_PUSH_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x, struct zx_hrxml_SecurityCredential_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SecurityCredential->gg.g;
  x->SecurityCredential = z;
}

/* FUNC(zx_hrxml_SecurityCredentials_REV_SecurityCredential) */

void zx_hrxml_SecurityCredentials_REV_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x)
{
  struct zx_hrxml_SecurityCredential_s* nxt;
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x) return;
  y = x->SecurityCredential;
  if (!y) return;
  x->SecurityCredential = 0;
  while (y) {
    nxt = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n;
    y->gg.g.n = &x->SecurityCredential->gg.g;
    x->SecurityCredential = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SecurityCredentials_PUT_SecurityCredential) */

void zx_hrxml_SecurityCredentials_PUT_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x, int n, struct zx_hrxml_SecurityCredential_s* z)
{
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x || !z) return;
  y = x->SecurityCredential;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SecurityCredential = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SecurityCredentials_ADD_SecurityCredential) */

void zx_hrxml_SecurityCredentials_ADD_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x, int n, struct zx_hrxml_SecurityCredential_s* z)
{
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SecurityCredential->gg.g;
    x->SecurityCredential = z;
    return;
  case -1:
    y = x->SecurityCredential;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SecurityCredential; n > 1 && y; --n, y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SecurityCredentials_DEL_SecurityCredential) */

void zx_hrxml_SecurityCredentials_DEL_SecurityCredential(struct zx_hrxml_SecurityCredentials_s* x, int n)
{
  struct zx_hrxml_SecurityCredential_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SecurityCredential = (struct zx_hrxml_SecurityCredential_s*)x->SecurityCredential->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SecurityCredential_s*)x->SecurityCredential;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SecurityCredential; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SecurityCredential_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_UnitOrDivision) */

int zx_hrxml_ServiceDetail_NUM_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UnitOrDivision; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_UnitOrDivision) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->UnitOrDivision; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_UnitOrDivision) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->UnitOrDivision;
  if (y)
    x->UnitOrDivision = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_UnitOrDivision) */

void zx_hrxml_ServiceDetail_PUSH_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->UnitOrDivision->g;
  x->UnitOrDivision = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_UnitOrDivision) */

void zx_hrxml_ServiceDetail_REV_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->UnitOrDivision;
  if (!y) return;
  x->UnitOrDivision = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->UnitOrDivision->g;
    x->UnitOrDivision = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_UnitOrDivision) */

void zx_hrxml_ServiceDetail_PUT_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->UnitOrDivision;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->UnitOrDivision = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_UnitOrDivision) */

void zx_hrxml_ServiceDetail_ADD_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->UnitOrDivision->g;
    x->UnitOrDivision = z;
    return;
  case -1:
    y = x->UnitOrDivision;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->UnitOrDivision; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_UnitOrDivision) */

void zx_hrxml_ServiceDetail_DEL_UnitOrDivision(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UnitOrDivision = (struct zx_elem_s*)x->UnitOrDivision->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->UnitOrDivision;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->UnitOrDivision; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_RankAchieved) */

int zx_hrxml_ServiceDetail_NUM_RankAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_RankAchieved_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RankAchieved; y; ++n, y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_RankAchieved) */

struct zx_hrxml_RankAchieved_s* zx_hrxml_ServiceDetail_GET_RankAchieved(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_RankAchieved_s* y;
  if (!x) return 0;
  for (y = x->RankAchieved; n>=0 && y; --n, y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_RankAchieved) */

struct zx_hrxml_RankAchieved_s* zx_hrxml_ServiceDetail_POP_RankAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_RankAchieved_s* y;
  if (!x) return 0;
  y = x->RankAchieved;
  if (y)
    x->RankAchieved = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_RankAchieved) */

void zx_hrxml_ServiceDetail_PUSH_RankAchieved(struct zx_hrxml_ServiceDetail_s* x, struct zx_hrxml_RankAchieved_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->RankAchieved->gg.g;
  x->RankAchieved = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_RankAchieved) */

void zx_hrxml_ServiceDetail_REV_RankAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_RankAchieved_s* nxt;
  struct zx_hrxml_RankAchieved_s* y;
  if (!x) return;
  y = x->RankAchieved;
  if (!y) return;
  x->RankAchieved = 0;
  while (y) {
    nxt = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n;
    y->gg.g.n = &x->RankAchieved->gg.g;
    x->RankAchieved = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_RankAchieved) */

void zx_hrxml_ServiceDetail_PUT_RankAchieved(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_RankAchieved_s* z)
{
  struct zx_hrxml_RankAchieved_s* y;
  if (!x || !z) return;
  y = x->RankAchieved;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->RankAchieved = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_RankAchieved) */

void zx_hrxml_ServiceDetail_ADD_RankAchieved(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_RankAchieved_s* z)
{
  struct zx_hrxml_RankAchieved_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->RankAchieved->gg.g;
    x->RankAchieved = z;
    return;
  case -1:
    y = x->RankAchieved;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankAchieved; n > 1 && y; --n, y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_RankAchieved) */

void zx_hrxml_ServiceDetail_DEL_RankAchieved(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_RankAchieved_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RankAchieved = (struct zx_hrxml_RankAchieved_s*)x->RankAchieved->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_RankAchieved_s*)x->RankAchieved;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->RankAchieved; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_RankAchieved_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_DatesOfService) */

int zx_hrxml_ServiceDetail_NUM_DatesOfService(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_DatesOfService_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DatesOfService; y; ++n, y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_DatesOfService) */

struct zx_hrxml_DatesOfService_s* zx_hrxml_ServiceDetail_GET_DatesOfService(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_DatesOfService_s* y;
  if (!x) return 0;
  for (y = x->DatesOfService; n>=0 && y; --n, y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_DatesOfService) */

struct zx_hrxml_DatesOfService_s* zx_hrxml_ServiceDetail_POP_DatesOfService(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_DatesOfService_s* y;
  if (!x) return 0;
  y = x->DatesOfService;
  if (y)
    x->DatesOfService = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_DatesOfService) */

void zx_hrxml_ServiceDetail_PUSH_DatesOfService(struct zx_hrxml_ServiceDetail_s* x, struct zx_hrxml_DatesOfService_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->DatesOfService->gg.g;
  x->DatesOfService = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_DatesOfService) */

void zx_hrxml_ServiceDetail_REV_DatesOfService(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_DatesOfService_s* nxt;
  struct zx_hrxml_DatesOfService_s* y;
  if (!x) return;
  y = x->DatesOfService;
  if (!y) return;
  x->DatesOfService = 0;
  while (y) {
    nxt = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n;
    y->gg.g.n = &x->DatesOfService->gg.g;
    x->DatesOfService = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_DatesOfService) */

void zx_hrxml_ServiceDetail_PUT_DatesOfService(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_DatesOfService_s* z)
{
  struct zx_hrxml_DatesOfService_s* y;
  if (!x || !z) return;
  y = x->DatesOfService;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->DatesOfService = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_DatesOfService) */

void zx_hrxml_ServiceDetail_ADD_DatesOfService(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_DatesOfService_s* z)
{
  struct zx_hrxml_DatesOfService_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->DatesOfService->gg.g;
    x->DatesOfService = z;
    return;
  case -1:
    y = x->DatesOfService;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfService; n > 1 && y; --n, y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_DatesOfService) */

void zx_hrxml_ServiceDetail_DEL_DatesOfService(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_DatesOfService_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DatesOfService = (struct zx_hrxml_DatesOfService_s*)x->DatesOfService->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_DatesOfService_s*)x->DatesOfService;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->DatesOfService; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_DatesOfService_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_Campaign) */

int zx_hrxml_ServiceDetail_NUM_Campaign(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Campaign; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_Campaign) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_Campaign(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Campaign; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_Campaign) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_Campaign(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Campaign;
  if (y)
    x->Campaign = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_Campaign) */

void zx_hrxml_ServiceDetail_PUSH_Campaign(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Campaign->g;
  x->Campaign = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_Campaign) */

void zx_hrxml_ServiceDetail_REV_Campaign(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Campaign;
  if (!y) return;
  x->Campaign = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Campaign->g;
    x->Campaign = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_Campaign) */

void zx_hrxml_ServiceDetail_PUT_Campaign(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Campaign;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Campaign = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_Campaign) */

void zx_hrxml_ServiceDetail_ADD_Campaign(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Campaign->g;
    x->Campaign = z;
    return;
  case -1:
    y = x->Campaign;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Campaign; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_Campaign) */

void zx_hrxml_ServiceDetail_DEL_Campaign(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Campaign = (struct zx_elem_s*)x->Campaign->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Campaign;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Campaign; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_AreaOfExpertise) */

int zx_hrxml_ServiceDetail_NUM_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AreaOfExpertise; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_AreaOfExpertise) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AreaOfExpertise; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_AreaOfExpertise) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AreaOfExpertise;
  if (y)
    x->AreaOfExpertise = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_AreaOfExpertise) */

void zx_hrxml_ServiceDetail_PUSH_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AreaOfExpertise->g;
  x->AreaOfExpertise = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_AreaOfExpertise) */

void zx_hrxml_ServiceDetail_REV_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AreaOfExpertise;
  if (!y) return;
  x->AreaOfExpertise = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AreaOfExpertise->g;
    x->AreaOfExpertise = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_AreaOfExpertise) */

void zx_hrxml_ServiceDetail_PUT_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AreaOfExpertise;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AreaOfExpertise = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_AreaOfExpertise) */

void zx_hrxml_ServiceDetail_ADD_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AreaOfExpertise->g;
    x->AreaOfExpertise = z;
    return;
  case -1:
    y = x->AreaOfExpertise;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AreaOfExpertise; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_AreaOfExpertise) */

void zx_hrxml_ServiceDetail_DEL_AreaOfExpertise(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AreaOfExpertise = (struct zx_elem_s*)x->AreaOfExpertise->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AreaOfExpertise;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AreaOfExpertise; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_RecognitionAchieved) */

int zx_hrxml_ServiceDetail_NUM_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RecognitionAchieved; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_RecognitionAchieved) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->RecognitionAchieved; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_RecognitionAchieved) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->RecognitionAchieved;
  if (y)
    x->RecognitionAchieved = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_RecognitionAchieved) */

void zx_hrxml_ServiceDetail_PUSH_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->RecognitionAchieved->g;
  x->RecognitionAchieved = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_RecognitionAchieved) */

void zx_hrxml_ServiceDetail_REV_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->RecognitionAchieved;
  if (!y) return;
  x->RecognitionAchieved = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->RecognitionAchieved->g;
    x->RecognitionAchieved = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_RecognitionAchieved) */

void zx_hrxml_ServiceDetail_PUT_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->RecognitionAchieved;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->RecognitionAchieved = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_RecognitionAchieved) */

void zx_hrxml_ServiceDetail_ADD_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->RecognitionAchieved->g;
    x->RecognitionAchieved = z;
    return;
  case -1:
    y = x->RecognitionAchieved;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RecognitionAchieved; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_RecognitionAchieved) */

void zx_hrxml_ServiceDetail_DEL_RecognitionAchieved(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RecognitionAchieved = (struct zx_elem_s*)x->RecognitionAchieved->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->RecognitionAchieved;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RecognitionAchieved; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_DisciplinaryAction) */

int zx_hrxml_ServiceDetail_NUM_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DisciplinaryAction; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_DisciplinaryAction) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DisciplinaryAction; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_DisciplinaryAction) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DisciplinaryAction;
  if (y)
    x->DisciplinaryAction = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_DisciplinaryAction) */

void zx_hrxml_ServiceDetail_PUSH_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DisciplinaryAction->g;
  x->DisciplinaryAction = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_DisciplinaryAction) */

void zx_hrxml_ServiceDetail_REV_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DisciplinaryAction;
  if (!y) return;
  x->DisciplinaryAction = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DisciplinaryAction->g;
    x->DisciplinaryAction = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_DisciplinaryAction) */

void zx_hrxml_ServiceDetail_PUT_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DisciplinaryAction;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DisciplinaryAction = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_DisciplinaryAction) */

void zx_hrxml_ServiceDetail_ADD_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DisciplinaryAction->g;
    x->DisciplinaryAction = z;
    return;
  case -1:
    y = x->DisciplinaryAction;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DisciplinaryAction; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_DisciplinaryAction) */

void zx_hrxml_ServiceDetail_DEL_DisciplinaryAction(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DisciplinaryAction = (struct zx_elem_s*)x->DisciplinaryAction->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DisciplinaryAction;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DisciplinaryAction; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_DischargeStatus) */

int zx_hrxml_ServiceDetail_NUM_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->DischargeStatus; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_DischargeStatus) */

struct zx_elem_s* zx_hrxml_ServiceDetail_GET_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->DischargeStatus; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_DischargeStatus) */

struct zx_elem_s* zx_hrxml_ServiceDetail_POP_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->DischargeStatus;
  if (y)
    x->DischargeStatus = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_DischargeStatus) */

void zx_hrxml_ServiceDetail_PUSH_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->DischargeStatus->g;
  x->DischargeStatus = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_DischargeStatus) */

void zx_hrxml_ServiceDetail_REV_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->DischargeStatus;
  if (!y) return;
  x->DischargeStatus = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->DischargeStatus->g;
    x->DischargeStatus = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_DischargeStatus) */

void zx_hrxml_ServiceDetail_PUT_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->DischargeStatus;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->DischargeStatus = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_DischargeStatus) */

void zx_hrxml_ServiceDetail_ADD_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->DischargeStatus->g;
    x->DischargeStatus = z;
    return;
  case -1:
    y = x->DischargeStatus;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DischargeStatus; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_DischargeStatus) */

void zx_hrxml_ServiceDetail_DEL_DischargeStatus(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->DischargeStatus = (struct zx_elem_s*)x->DischargeStatus->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->DischargeStatus;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->DischargeStatus; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceDetail_NUM_UserArea) */

int zx_hrxml_ServiceDetail_NUM_UserArea(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceDetail_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_ServiceDetail_GET_UserArea(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_ServiceDetail_POP_UserArea(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceDetail_PUSH_UserArea) */

void zx_hrxml_ServiceDetail_PUSH_UserArea(struct zx_hrxml_ServiceDetail_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_ServiceDetail_REV_UserArea) */

void zx_hrxml_ServiceDetail_REV_UserArea(struct zx_hrxml_ServiceDetail_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_PUT_UserArea) */

void zx_hrxml_ServiceDetail_PUT_UserArea(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ServiceDetail_ADD_UserArea) */

void zx_hrxml_ServiceDetail_ADD_UserArea(struct zx_hrxml_ServiceDetail_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ServiceDetail_DEL_UserArea) */

void zx_hrxml_ServiceDetail_DEL_UserArea(struct zx_hrxml_ServiceDetail_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ServiceDetail_GET_branch) */
struct zx_str* zx_hrxml_ServiceDetail_GET_branch(struct zx_hrxml_ServiceDetail_s* x) { return x->branch; }
/* FUNC(zx_hrxml_ServiceDetail_PUT_branch) */
void zx_hrxml_ServiceDetail_PUT_branch(struct zx_hrxml_ServiceDetail_s* x, struct zx_str* y) { x->branch = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ServiceNumber_NUM_IdValue) */

int zx_hrxml_ServiceNumber_NUM_IdValue(struct zx_hrxml_ServiceNumber_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ServiceNumber_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ServiceNumber_GET_IdValue(struct zx_hrxml_ServiceNumber_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ServiceNumber_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_ServiceNumber_POP_IdValue(struct zx_hrxml_ServiceNumber_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_ServiceNumber_PUSH_IdValue) */

void zx_hrxml_ServiceNumber_PUSH_IdValue(struct zx_hrxml_ServiceNumber_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_ServiceNumber_REV_IdValue) */

void zx_hrxml_ServiceNumber_REV_IdValue(struct zx_hrxml_ServiceNumber_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ServiceNumber_PUT_IdValue) */

void zx_hrxml_ServiceNumber_PUT_IdValue(struct zx_hrxml_ServiceNumber_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_ServiceNumber_ADD_IdValue) */

void zx_hrxml_ServiceNumber_ADD_IdValue(struct zx_hrxml_ServiceNumber_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_ServiceNumber_DEL_IdValue) */

void zx_hrxml_ServiceNumber_DEL_IdValue(struct zx_hrxml_ServiceNumber_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_ServiceNumber_GET_idOwner) */
struct zx_str* zx_hrxml_ServiceNumber_GET_idOwner(struct zx_hrxml_ServiceNumber_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_ServiceNumber_PUT_idOwner) */
void zx_hrxml_ServiceNumber_PUT_idOwner(struct zx_hrxml_ServiceNumber_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_ServiceNumber_GET_validFrom) */
struct zx_str* zx_hrxml_ServiceNumber_GET_validFrom(struct zx_hrxml_ServiceNumber_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_ServiceNumber_PUT_validFrom) */
void zx_hrxml_ServiceNumber_PUT_validFrom(struct zx_hrxml_ServiceNumber_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_ServiceNumber_GET_validTo) */
struct zx_str* zx_hrxml_ServiceNumber_GET_validTo(struct zx_hrxml_ServiceNumber_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_ServiceNumber_PUT_validTo) */
void zx_hrxml_ServiceNumber_PUT_validTo(struct zx_hrxml_ServiceNumber_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_Id) */

int zx_hrxml_Shift_NUM_Id(struct zx_hrxml_Shift_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Shift_GET_Id(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Shift_POP_Id(struct zx_hrxml_Shift_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_Id) */

void zx_hrxml_Shift_PUSH_Id(struct zx_hrxml_Shift_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_Shift_REV_Id) */

void zx_hrxml_Shift_REV_Id(struct zx_hrxml_Shift_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_Id) */

void zx_hrxml_Shift_PUT_Id(struct zx_hrxml_Shift_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_Id) */

void zx_hrxml_Shift_ADD_Id(struct zx_hrxml_Shift_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Shift_DEL_Id) */

void zx_hrxml_Shift_DEL_Id(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_Name) */

int zx_hrxml_Shift_NUM_Name(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Name; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_Name) */

struct zx_elem_s* zx_hrxml_Shift_GET_Name(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Name; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_Name) */

struct zx_elem_s* zx_hrxml_Shift_POP_Name(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Name;
  if (y)
    x->Name = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_Name) */

void zx_hrxml_Shift_PUSH_Name(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Name->g;
  x->Name = z;
}

/* FUNC(zx_hrxml_Shift_REV_Name) */

void zx_hrxml_Shift_REV_Name(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Name;
  if (!y) return;
  x->Name = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Name->g;
    x->Name = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_Name) */

void zx_hrxml_Shift_PUT_Name(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Name;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Name = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_Name) */

void zx_hrxml_Shift_ADD_Name(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Name->g;
    x->Name = z;
    return;
  case -1:
    y = x->Name;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_Name) */

void zx_hrxml_Shift_DEL_Name(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Name = (struct zx_elem_s*)x->Name->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Name;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Name; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_Hours) */

int zx_hrxml_Shift_NUM_Hours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Hours; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_Hours) */

struct zx_elem_s* zx_hrxml_Shift_GET_Hours(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Hours; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_Hours) */

struct zx_elem_s* zx_hrxml_Shift_POP_Hours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Hours;
  if (y)
    x->Hours = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_Hours) */

void zx_hrxml_Shift_PUSH_Hours(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Hours->g;
  x->Hours = z;
}

/* FUNC(zx_hrxml_Shift_REV_Hours) */

void zx_hrxml_Shift_REV_Hours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Hours;
  if (!y) return;
  x->Hours = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Hours->g;
    x->Hours = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_Hours) */

void zx_hrxml_Shift_PUT_Hours(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Hours;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Hours = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_Hours) */

void zx_hrxml_Shift_ADD_Hours(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Hours->g;
    x->Hours = z;
    return;
  case -1:
    y = x->Hours;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Hours; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_Hours) */

void zx_hrxml_Shift_DEL_Hours(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Hours = (struct zx_elem_s*)x->Hours->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Hours;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Hours; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_StartTime) */

int zx_hrxml_Shift_NUM_StartTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartTime; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_StartTime) */

struct zx_elem_s* zx_hrxml_Shift_GET_StartTime(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StartTime; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_StartTime) */

struct zx_elem_s* zx_hrxml_Shift_POP_StartTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StartTime;
  if (y)
    x->StartTime = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_StartTime) */

void zx_hrxml_Shift_PUSH_StartTime(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StartTime->g;
  x->StartTime = z;
}

/* FUNC(zx_hrxml_Shift_REV_StartTime) */

void zx_hrxml_Shift_REV_StartTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StartTime;
  if (!y) return;
  x->StartTime = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StartTime->g;
    x->StartTime = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_StartTime) */

void zx_hrxml_Shift_PUT_StartTime(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StartTime;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StartTime = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_StartTime) */

void zx_hrxml_Shift_ADD_StartTime(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StartTime->g;
    x->StartTime = z;
    return;
  case -1:
    y = x->StartTime;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StartTime; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_StartTime) */

void zx_hrxml_Shift_DEL_StartTime(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartTime = (struct zx_elem_s*)x->StartTime->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StartTime;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StartTime; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_EndTime) */

int zx_hrxml_Shift_NUM_EndTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndTime; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_EndTime) */

struct zx_elem_s* zx_hrxml_Shift_GET_EndTime(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EndTime; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_EndTime) */

struct zx_elem_s* zx_hrxml_Shift_POP_EndTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EndTime;
  if (y)
    x->EndTime = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_EndTime) */

void zx_hrxml_Shift_PUSH_EndTime(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EndTime->g;
  x->EndTime = z;
}

/* FUNC(zx_hrxml_Shift_REV_EndTime) */

void zx_hrxml_Shift_REV_EndTime(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EndTime;
  if (!y) return;
  x->EndTime = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EndTime->g;
    x->EndTime = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_EndTime) */

void zx_hrxml_Shift_PUT_EndTime(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EndTime;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EndTime = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_EndTime) */

void zx_hrxml_Shift_ADD_EndTime(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EndTime->g;
    x->EndTime = z;
    return;
  case -1:
    y = x->EndTime;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EndTime; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_EndTime) */

void zx_hrxml_Shift_DEL_EndTime(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndTime = (struct zx_elem_s*)x->EndTime->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EndTime;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EndTime; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_PayTypeHours) */

int zx_hrxml_Shift_NUM_PayTypeHours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PayTypeHours; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_PayTypeHours) */

struct zx_elem_s* zx_hrxml_Shift_GET_PayTypeHours(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PayTypeHours; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_PayTypeHours) */

struct zx_elem_s* zx_hrxml_Shift_POP_PayTypeHours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PayTypeHours;
  if (y)
    x->PayTypeHours = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_PayTypeHours) */

void zx_hrxml_Shift_PUSH_PayTypeHours(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PayTypeHours->g;
  x->PayTypeHours = z;
}

/* FUNC(zx_hrxml_Shift_REV_PayTypeHours) */

void zx_hrxml_Shift_REV_PayTypeHours(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PayTypeHours;
  if (!y) return;
  x->PayTypeHours = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PayTypeHours->g;
    x->PayTypeHours = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_PayTypeHours) */

void zx_hrxml_Shift_PUT_PayTypeHours(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PayTypeHours;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PayTypeHours = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_PayTypeHours) */

void zx_hrxml_Shift_ADD_PayTypeHours(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PayTypeHours->g;
    x->PayTypeHours = z;
    return;
  case -1:
    y = x->PayTypeHours;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PayTypeHours; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_PayTypeHours) */

void zx_hrxml_Shift_DEL_PayTypeHours(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PayTypeHours = (struct zx_elem_s*)x->PayTypeHours->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PayTypeHours;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PayTypeHours; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Shift_NUM_Comments) */

int zx_hrxml_Shift_NUM_Comments(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Shift_GET_Comments) */

struct zx_elem_s* zx_hrxml_Shift_GET_Comments(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Shift_POP_Comments) */

struct zx_elem_s* zx_hrxml_Shift_POP_Comments(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Shift_PUSH_Comments) */

void zx_hrxml_Shift_PUSH_Comments(struct zx_hrxml_Shift_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_Shift_REV_Comments) */

void zx_hrxml_Shift_REV_Comments(struct zx_hrxml_Shift_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Shift_PUT_Comments) */

void zx_hrxml_Shift_PUT_Comments(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Shift_ADD_Comments) */

void zx_hrxml_Shift_ADD_Comments(struct zx_hrxml_Shift_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Shift_DEL_Comments) */

void zx_hrxml_Shift_DEL_Comments(struct zx_hrxml_Shift_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_Shift_GET_shiftPeriod) */
struct zx_str* zx_hrxml_Shift_GET_shiftPeriod(struct zx_hrxml_Shift_s* x) { return x->shiftPeriod; }
/* FUNC(zx_hrxml_Shift_PUT_shiftPeriod) */
void zx_hrxml_Shift_PUT_shiftPeriod(struct zx_hrxml_Shift_s* x, struct zx_str* y) { x->shiftPeriod = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SourceType_NUM_StandardValue) */

int zx_hrxml_SourceType_NUM_StandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StandardValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SourceType_GET_StandardValue) */

struct zx_elem_s* zx_hrxml_SourceType_GET_StandardValue(struct zx_hrxml_SourceType_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StandardValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SourceType_POP_StandardValue) */

struct zx_elem_s* zx_hrxml_SourceType_POP_StandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StandardValue;
  if (y)
    x->StandardValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SourceType_PUSH_StandardValue) */

void zx_hrxml_SourceType_PUSH_StandardValue(struct zx_hrxml_SourceType_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StandardValue->g;
  x->StandardValue = z;
}

/* FUNC(zx_hrxml_SourceType_REV_StandardValue) */

void zx_hrxml_SourceType_REV_StandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StandardValue;
  if (!y) return;
  x->StandardValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StandardValue->g;
    x->StandardValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SourceType_PUT_StandardValue) */

void zx_hrxml_SourceType_PUT_StandardValue(struct zx_hrxml_SourceType_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StandardValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StandardValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SourceType_ADD_StandardValue) */

void zx_hrxml_SourceType_ADD_StandardValue(struct zx_hrxml_SourceType_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StandardValue->g;
    x->StandardValue = z;
    return;
  case -1:
    y = x->StandardValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StandardValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SourceType_DEL_StandardValue) */

void zx_hrxml_SourceType_DEL_StandardValue(struct zx_hrxml_SourceType_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StandardValue = (struct zx_elem_s*)x->StandardValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StandardValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StandardValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SourceType_NUM_NonStandardValue) */

int zx_hrxml_SourceType_NUM_NonStandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->NonStandardValue; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SourceType_GET_NonStandardValue) */

struct zx_elem_s* zx_hrxml_SourceType_GET_NonStandardValue(struct zx_hrxml_SourceType_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->NonStandardValue; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SourceType_POP_NonStandardValue) */

struct zx_elem_s* zx_hrxml_SourceType_POP_NonStandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->NonStandardValue;
  if (y)
    x->NonStandardValue = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SourceType_PUSH_NonStandardValue) */

void zx_hrxml_SourceType_PUSH_NonStandardValue(struct zx_hrxml_SourceType_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->NonStandardValue->g;
  x->NonStandardValue = z;
}

/* FUNC(zx_hrxml_SourceType_REV_NonStandardValue) */

void zx_hrxml_SourceType_REV_NonStandardValue(struct zx_hrxml_SourceType_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->NonStandardValue;
  if (!y) return;
  x->NonStandardValue = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->NonStandardValue->g;
    x->NonStandardValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SourceType_PUT_NonStandardValue) */

void zx_hrxml_SourceType_PUT_NonStandardValue(struct zx_hrxml_SourceType_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->NonStandardValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->NonStandardValue = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SourceType_ADD_NonStandardValue) */

void zx_hrxml_SourceType_ADD_NonStandardValue(struct zx_hrxml_SourceType_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->NonStandardValue->g;
    x->NonStandardValue = z;
    return;
  case -1:
    y = x->NonStandardValue;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NonStandardValue; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SourceType_DEL_NonStandardValue) */

void zx_hrxml_SourceType_DEL_NonStandardValue(struct zx_hrxml_SourceType_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->NonStandardValue = (struct zx_elem_s*)x->NonStandardValue->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->NonStandardValue;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->NonStandardValue; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_Latitude) */

int zx_hrxml_SpatialLocation_NUM_Latitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Latitude_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Latitude; y; ++n, y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_Latitude) */

struct zx_hrxml_Latitude_s* zx_hrxml_SpatialLocation_GET_Latitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_Latitude_s* y;
  if (!x) return 0;
  for (y = x->Latitude; n>=0 && y; --n, y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_Latitude) */

struct zx_hrxml_Latitude_s* zx_hrxml_SpatialLocation_POP_Latitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Latitude_s* y;
  if (!x) return 0;
  y = x->Latitude;
  if (y)
    x->Latitude = (struct zx_hrxml_Latitude_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_Latitude) */

void zx_hrxml_SpatialLocation_PUSH_Latitude(struct zx_hrxml_SpatialLocation_s* x, struct zx_hrxml_Latitude_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Latitude->gg.g;
  x->Latitude = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_Latitude) */

void zx_hrxml_SpatialLocation_REV_Latitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Latitude_s* nxt;
  struct zx_hrxml_Latitude_s* y;
  if (!x) return;
  y = x->Latitude;
  if (!y) return;
  x->Latitude = 0;
  while (y) {
    nxt = (struct zx_hrxml_Latitude_s*)y->gg.g.n;
    y->gg.g.n = &x->Latitude->gg.g;
    x->Latitude = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_Latitude) */

void zx_hrxml_SpatialLocation_PUT_Latitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_Latitude_s* z)
{
  struct zx_hrxml_Latitude_s* y;
  if (!x || !z) return;
  y = x->Latitude;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Latitude = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_Latitude) */

void zx_hrxml_SpatialLocation_ADD_Latitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_Latitude_s* z)
{
  struct zx_hrxml_Latitude_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Latitude->gg.g;
    x->Latitude = z;
    return;
  case -1:
    y = x->Latitude;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Latitude; n > 1 && y; --n, y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_Latitude) */

void zx_hrxml_SpatialLocation_DEL_Latitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_Latitude_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Latitude = (struct zx_hrxml_Latitude_s*)x->Latitude->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Latitude_s*)x->Latitude;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Latitude; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Latitude_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_Longitude) */

int zx_hrxml_SpatialLocation_NUM_Longitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Longitude_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Longitude; y; ++n, y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_Longitude) */

struct zx_hrxml_Longitude_s* zx_hrxml_SpatialLocation_GET_Longitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_Longitude_s* y;
  if (!x) return 0;
  for (y = x->Longitude; n>=0 && y; --n, y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_Longitude) */

struct zx_hrxml_Longitude_s* zx_hrxml_SpatialLocation_POP_Longitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Longitude_s* y;
  if (!x) return 0;
  y = x->Longitude;
  if (y)
    x->Longitude = (struct zx_hrxml_Longitude_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_Longitude) */

void zx_hrxml_SpatialLocation_PUSH_Longitude(struct zx_hrxml_SpatialLocation_s* x, struct zx_hrxml_Longitude_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Longitude->gg.g;
  x->Longitude = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_Longitude) */

void zx_hrxml_SpatialLocation_REV_Longitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_Longitude_s* nxt;
  struct zx_hrxml_Longitude_s* y;
  if (!x) return;
  y = x->Longitude;
  if (!y) return;
  x->Longitude = 0;
  while (y) {
    nxt = (struct zx_hrxml_Longitude_s*)y->gg.g.n;
    y->gg.g.n = &x->Longitude->gg.g;
    x->Longitude = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_Longitude) */

void zx_hrxml_SpatialLocation_PUT_Longitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_Longitude_s* z)
{
  struct zx_hrxml_Longitude_s* y;
  if (!x || !z) return;
  y = x->Longitude;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Longitude = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_Longitude) */

void zx_hrxml_SpatialLocation_ADD_Longitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_Longitude_s* z)
{
  struct zx_hrxml_Longitude_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Longitude->gg.g;
    x->Longitude = z;
    return;
  case -1:
    y = x->Longitude;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Longitude; n > 1 && y; --n, y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_Longitude) */

void zx_hrxml_SpatialLocation_DEL_Longitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_Longitude_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Longitude = (struct zx_hrxml_Longitude_s*)x->Longitude->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Longitude_s*)x->Longitude;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Longitude; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Longitude_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_Altitude) */

int zx_hrxml_SpatialLocation_NUM_Altitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Altitude; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_Altitude) */

struct zx_elem_s* zx_hrxml_SpatialLocation_GET_Altitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Altitude; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_Altitude) */

struct zx_elem_s* zx_hrxml_SpatialLocation_POP_Altitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Altitude;
  if (y)
    x->Altitude = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_Altitude) */

void zx_hrxml_SpatialLocation_PUSH_Altitude(struct zx_hrxml_SpatialLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Altitude->g;
  x->Altitude = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_Altitude) */

void zx_hrxml_SpatialLocation_REV_Altitude(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Altitude;
  if (!y) return;
  x->Altitude = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Altitude->g;
    x->Altitude = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_Altitude) */

void zx_hrxml_SpatialLocation_PUT_Altitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Altitude;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Altitude = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_Altitude) */

void zx_hrxml_SpatialLocation_ADD_Altitude(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Altitude->g;
    x->Altitude = z;
    return;
  case -1:
    y = x->Altitude;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Altitude; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_Altitude) */

void zx_hrxml_SpatialLocation_DEL_Altitude(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Altitude = (struct zx_elem_s*)x->Altitude->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Altitude;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Altitude; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_AltitudeMeanSeaLevel) */

int zx_hrxml_SpatialLocation_NUM_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AltitudeMeanSeaLevel; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_AltitudeMeanSeaLevel) */

struct zx_elem_s* zx_hrxml_SpatialLocation_GET_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AltitudeMeanSeaLevel; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_AltitudeMeanSeaLevel) */

struct zx_elem_s* zx_hrxml_SpatialLocation_POP_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AltitudeMeanSeaLevel;
  if (y)
    x->AltitudeMeanSeaLevel = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_AltitudeMeanSeaLevel) */

void zx_hrxml_SpatialLocation_PUSH_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AltitudeMeanSeaLevel->g;
  x->AltitudeMeanSeaLevel = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_AltitudeMeanSeaLevel) */

void zx_hrxml_SpatialLocation_REV_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AltitudeMeanSeaLevel;
  if (!y) return;
  x->AltitudeMeanSeaLevel = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AltitudeMeanSeaLevel->g;
    x->AltitudeMeanSeaLevel = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_AltitudeMeanSeaLevel) */

void zx_hrxml_SpatialLocation_PUT_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AltitudeMeanSeaLevel;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AltitudeMeanSeaLevel = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_AltitudeMeanSeaLevel) */

void zx_hrxml_SpatialLocation_ADD_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AltitudeMeanSeaLevel->g;
    x->AltitudeMeanSeaLevel = z;
    return;
  case -1:
    y = x->AltitudeMeanSeaLevel;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AltitudeMeanSeaLevel; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_AltitudeMeanSeaLevel) */

void zx_hrxml_SpatialLocation_DEL_AltitudeMeanSeaLevel(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AltitudeMeanSeaLevel = (struct zx_elem_s*)x->AltitudeMeanSeaLevel->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AltitudeMeanSeaLevel;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AltitudeMeanSeaLevel; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_HorizontalAccuracy) */

int zx_hrxml_SpatialLocation_NUM_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->HorizontalAccuracy; y; ++n, y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_HorizontalAccuracy) */

struct zx_hrxml_HorizontalAccuracy_s* zx_hrxml_SpatialLocation_GET_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x) return 0;
  for (y = x->HorizontalAccuracy; n>=0 && y; --n, y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_HorizontalAccuracy) */

struct zx_hrxml_HorizontalAccuracy_s* zx_hrxml_SpatialLocation_POP_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x) return 0;
  y = x->HorizontalAccuracy;
  if (y)
    x->HorizontalAccuracy = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_HorizontalAccuracy) */

void zx_hrxml_SpatialLocation_PUSH_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x, struct zx_hrxml_HorizontalAccuracy_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->HorizontalAccuracy->gg.g;
  x->HorizontalAccuracy = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_HorizontalAccuracy) */

void zx_hrxml_SpatialLocation_REV_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_HorizontalAccuracy_s* nxt;
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x) return;
  y = x->HorizontalAccuracy;
  if (!y) return;
  x->HorizontalAccuracy = 0;
  while (y) {
    nxt = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n;
    y->gg.g.n = &x->HorizontalAccuracy->gg.g;
    x->HorizontalAccuracy = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_HorizontalAccuracy) */

void zx_hrxml_SpatialLocation_PUT_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_HorizontalAccuracy_s* z)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x || !z) return;
  y = x->HorizontalAccuracy;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->HorizontalAccuracy = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_HorizontalAccuracy) */

void zx_hrxml_SpatialLocation_ADD_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_HorizontalAccuracy_s* z)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->HorizontalAccuracy->gg.g;
    x->HorizontalAccuracy = z;
    return;
  case -1:
    y = x->HorizontalAccuracy;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->HorizontalAccuracy; n > 1 && y; --n, y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_HorizontalAccuracy) */

void zx_hrxml_SpatialLocation_DEL_HorizontalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_HorizontalAccuracy_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->HorizontalAccuracy = (struct zx_hrxml_HorizontalAccuracy_s*)x->HorizontalAccuracy->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_HorizontalAccuracy_s*)x->HorizontalAccuracy;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->HorizontalAccuracy; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_HorizontalAccuracy_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpatialLocation_NUM_VerticalAccuracy) */

int zx_hrxml_SpatialLocation_NUM_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->VerticalAccuracy; y; ++n, y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpatialLocation_GET_VerticalAccuracy) */

struct zx_hrxml_VerticalAccuracy_s* zx_hrxml_SpatialLocation_GET_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x) return 0;
  for (y = x->VerticalAccuracy; n>=0 && y; --n, y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_POP_VerticalAccuracy) */

struct zx_hrxml_VerticalAccuracy_s* zx_hrxml_SpatialLocation_POP_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x) return 0;
  y = x->VerticalAccuracy;
  if (y)
    x->VerticalAccuracy = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpatialLocation_PUSH_VerticalAccuracy) */

void zx_hrxml_SpatialLocation_PUSH_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x, struct zx_hrxml_VerticalAccuracy_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->VerticalAccuracy->gg.g;
  x->VerticalAccuracy = z;
}

/* FUNC(zx_hrxml_SpatialLocation_REV_VerticalAccuracy) */

void zx_hrxml_SpatialLocation_REV_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x)
{
  struct zx_hrxml_VerticalAccuracy_s* nxt;
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x) return;
  y = x->VerticalAccuracy;
  if (!y) return;
  x->VerticalAccuracy = 0;
  while (y) {
    nxt = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n;
    y->gg.g.n = &x->VerticalAccuracy->gg.g;
    x->VerticalAccuracy = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_PUT_VerticalAccuracy) */

void zx_hrxml_SpatialLocation_PUT_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_VerticalAccuracy_s* z)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x || !z) return;
  y = x->VerticalAccuracy;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->VerticalAccuracy = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpatialLocation_ADD_VerticalAccuracy) */

void zx_hrxml_SpatialLocation_ADD_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n, struct zx_hrxml_VerticalAccuracy_s* z)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->VerticalAccuracy->gg.g;
    x->VerticalAccuracy = z;
    return;
  case -1:
    y = x->VerticalAccuracy;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->VerticalAccuracy; n > 1 && y; --n, y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpatialLocation_DEL_VerticalAccuracy) */

void zx_hrxml_SpatialLocation_DEL_VerticalAccuracy(struct zx_hrxml_SpatialLocation_s* x, int n)
{
  struct zx_hrxml_VerticalAccuracy_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->VerticalAccuracy = (struct zx_hrxml_VerticalAccuracy_s*)x->VerticalAccuracy->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_VerticalAccuracy_s*)x->VerticalAccuracy;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->VerticalAccuracy; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_VerticalAccuracy_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_Title) */

int zx_hrxml_SpeakingEvent_NUM_Title(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Title; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_Title) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_Title(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Title; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_Title) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_Title(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Title;
  if (y)
    x->Title = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_Title) */

void zx_hrxml_SpeakingEvent_PUSH_Title(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Title->g;
  x->Title = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_Title) */

void zx_hrxml_SpeakingEvent_REV_Title(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Title;
  if (!y) return;
  x->Title = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Title->g;
    x->Title = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_Title) */

void zx_hrxml_SpeakingEvent_PUT_Title(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Title;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Title = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_Title) */

void zx_hrxml_SpeakingEvent_ADD_Title(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Title->g;
    x->Title = z;
    return;
  case -1:
    y = x->Title;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_Title) */

void zx_hrxml_SpeakingEvent_DEL_Title(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Title = (struct zx_elem_s*)x->Title->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Title;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Title; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_Role) */

int zx_hrxml_SpeakingEvent_NUM_Role(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Role; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_Role) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_Role(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Role; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_Role) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_Role(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Role;
  if (y)
    x->Role = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_Role) */

void zx_hrxml_SpeakingEvent_PUSH_Role(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Role->g;
  x->Role = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_Role) */

void zx_hrxml_SpeakingEvent_REV_Role(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Role;
  if (!y) return;
  x->Role = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Role->g;
    x->Role = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_Role) */

void zx_hrxml_SpeakingEvent_PUT_Role(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Role;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Role = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_Role) */

void zx_hrxml_SpeakingEvent_ADD_Role(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Role->g;
    x->Role = z;
    return;
  case -1:
    y = x->Role;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Role; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_Role) */

void zx_hrxml_SpeakingEvent_DEL_Role(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Role = (struct zx_elem_s*)x->Role->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Role;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Role; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_StartDate) */

int zx_hrxml_SpeakingEvent_NUM_StartDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StartDate; y; ++n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_SpeakingEvent_GET_StartDate(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  for (y = x->StartDate; n>=0 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_StartDate) */

struct zx_hrxml_StartDate_s* zx_hrxml_SpeakingEvent_POP_StartDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return 0;
  y = x->StartDate;
  if (y)
    x->StartDate = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_StartDate) */

void zx_hrxml_SpeakingEvent_PUSH_StartDate(struct zx_hrxml_SpeakingEvent_s* x, struct zx_hrxml_StartDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->StartDate->gg.g;
  x->StartDate = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_StartDate) */

void zx_hrxml_SpeakingEvent_REV_StartDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_StartDate_s* nxt;
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  y = x->StartDate;
  if (!y) return;
  x->StartDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_StartDate_s*)y->gg.g.n;
    y->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_StartDate) */

void zx_hrxml_SpeakingEvent_PUT_StartDate(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  y = x->StartDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->StartDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_StartDate) */

void zx_hrxml_SpeakingEvent_ADD_StartDate(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_StartDate_s* z)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->StartDate->gg.g;
    x->StartDate = z;
    return;
  case -1:
    y = x->StartDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_StartDate) */

void zx_hrxml_SpeakingEvent_DEL_StartDate(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_StartDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StartDate = (struct zx_hrxml_StartDate_s*)x->StartDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_StartDate_s*)x->StartDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->StartDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_StartDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_EndDate) */

int zx_hrxml_SpeakingEvent_NUM_EndDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EndDate; y; ++n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_SpeakingEvent_GET_EndDate(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  for (y = x->EndDate; n>=0 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_EndDate) */

struct zx_hrxml_EndDate_s* zx_hrxml_SpeakingEvent_POP_EndDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return 0;
  y = x->EndDate;
  if (y)
    x->EndDate = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_EndDate) */

void zx_hrxml_SpeakingEvent_PUSH_EndDate(struct zx_hrxml_SpeakingEvent_s* x, struct zx_hrxml_EndDate_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EndDate->gg.g;
  x->EndDate = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_EndDate) */

void zx_hrxml_SpeakingEvent_REV_EndDate(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_EndDate_s* nxt;
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  y = x->EndDate;
  if (!y) return;
  x->EndDate = 0;
  while (y) {
    nxt = (struct zx_hrxml_EndDate_s*)y->gg.g.n;
    y->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_EndDate) */

void zx_hrxml_SpeakingEvent_PUT_EndDate(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  y = x->EndDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EndDate = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_EndDate) */

void zx_hrxml_SpeakingEvent_ADD_EndDate(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_EndDate_s* z)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EndDate->gg.g;
    x->EndDate = z;
    return;
  case -1:
    y = x->EndDate;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_EndDate) */

void zx_hrxml_SpeakingEvent_DEL_EndDate(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_EndDate_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EndDate = (struct zx_hrxml_EndDate_s*)x->EndDate->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EndDate_s*)x->EndDate;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EndDate; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EndDate_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_EventName) */

int zx_hrxml_SpeakingEvent_NUM_EventName(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EventName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_EventName) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_EventName(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EventName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_EventName) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_EventName(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EventName;
  if (y)
    x->EventName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_EventName) */

void zx_hrxml_SpeakingEvent_PUSH_EventName(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EventName->g;
  x->EventName = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_EventName) */

void zx_hrxml_SpeakingEvent_REV_EventName(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EventName;
  if (!y) return;
  x->EventName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EventName->g;
    x->EventName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_EventName) */

void zx_hrxml_SpeakingEvent_PUT_EventName(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EventName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EventName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_EventName) */

void zx_hrxml_SpeakingEvent_ADD_EventName(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EventName->g;
    x->EventName = z;
    return;
  case -1:
    y = x->EventName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_EventName) */

void zx_hrxml_SpeakingEvent_DEL_EventName(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EventName = (struct zx_elem_s*)x->EventName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EventName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_EventType) */

int zx_hrxml_SpeakingEvent_NUM_EventType(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EventType; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_EventType) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_EventType(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EventType; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_EventType) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_EventType(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EventType;
  if (y)
    x->EventType = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_EventType) */

void zx_hrxml_SpeakingEvent_PUSH_EventType(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EventType->g;
  x->EventType = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_EventType) */

void zx_hrxml_SpeakingEvent_REV_EventType(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EventType;
  if (!y) return;
  x->EventType = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EventType->g;
    x->EventType = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_EventType) */

void zx_hrxml_SpeakingEvent_PUT_EventType(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EventType;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EventType = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_EventType) */

void zx_hrxml_SpeakingEvent_ADD_EventType(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EventType->g;
    x->EventType = z;
    return;
  case -1:
    y = x->EventType;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventType; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_EventType) */

void zx_hrxml_SpeakingEvent_DEL_EventType(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EventType = (struct zx_elem_s*)x->EventType->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EventType;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EventType; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_Location) */

int zx_hrxml_SpeakingEvent_NUM_Location(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Location; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_Location) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_Location(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Location; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_Location) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_Location(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Location;
  if (y)
    x->Location = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_Location) */

void zx_hrxml_SpeakingEvent_PUSH_Location(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Location->g;
  x->Location = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_Location) */

void zx_hrxml_SpeakingEvent_REV_Location(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Location;
  if (!y) return;
  x->Location = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Location->g;
    x->Location = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_Location) */

void zx_hrxml_SpeakingEvent_PUT_Location(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Location;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Location = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_Location) */

void zx_hrxml_SpeakingEvent_ADD_Location(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Location->g;
    x->Location = z;
    return;
  case -1:
    y = x->Location;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Location; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_Location) */

void zx_hrxml_SpeakingEvent_DEL_Location(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Location = (struct zx_elem_s*)x->Location->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Location;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Location; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_Description) */

int zx_hrxml_SpeakingEvent_NUM_Description(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SpeakingEvent_GET_Description(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SpeakingEvent_POP_Description(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_Description) */

void zx_hrxml_SpeakingEvent_PUSH_Description(struct zx_hrxml_SpeakingEvent_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_Description) */

void zx_hrxml_SpeakingEvent_REV_Description(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_Description) */

void zx_hrxml_SpeakingEvent_PUT_Description(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_Description) */

void zx_hrxml_SpeakingEvent_ADD_Description(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_Description) */

void zx_hrxml_SpeakingEvent_DEL_Description(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_AffiliatedOrganization) */

int zx_hrxml_SpeakingEvent_NUM_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AffiliatedOrganization; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_AffiliatedOrganization) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AffiliatedOrganization; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_AffiliatedOrganization) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AffiliatedOrganization;
  if (y)
    x->AffiliatedOrganization = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_AffiliatedOrganization) */

void zx_hrxml_SpeakingEvent_PUSH_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AffiliatedOrganization->g;
  x->AffiliatedOrganization = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_AffiliatedOrganization) */

void zx_hrxml_SpeakingEvent_REV_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AffiliatedOrganization;
  if (!y) return;
  x->AffiliatedOrganization = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AffiliatedOrganization->g;
    x->AffiliatedOrganization = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_AffiliatedOrganization) */

void zx_hrxml_SpeakingEvent_PUT_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AffiliatedOrganization;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AffiliatedOrganization = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_AffiliatedOrganization) */

void zx_hrxml_SpeakingEvent_ADD_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AffiliatedOrganization->g;
    x->AffiliatedOrganization = z;
    return;
  case -1:
    y = x->AffiliatedOrganization;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AffiliatedOrganization; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_AffiliatedOrganization) */

void zx_hrxml_SpeakingEvent_DEL_AffiliatedOrganization(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AffiliatedOrganization = (struct zx_elem_s*)x->AffiliatedOrganization->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AffiliatedOrganization;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AffiliatedOrganization; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEvent_NUM_Link) */

int zx_hrxml_SpeakingEvent_NUM_Link(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEvent_GET_Link) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_GET_Link(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_POP_Link) */

struct zx_elem_s* zx_hrxml_SpeakingEvent_POP_Link(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEvent_PUSH_Link) */

void zx_hrxml_SpeakingEvent_PUSH_Link(struct zx_hrxml_SpeakingEvent_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_SpeakingEvent_REV_Link) */

void zx_hrxml_SpeakingEvent_REV_Link(struct zx_hrxml_SpeakingEvent_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_PUT_Link) */

void zx_hrxml_SpeakingEvent_PUT_Link(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpeakingEvent_ADD_Link) */

void zx_hrxml_SpeakingEvent_ADD_Link(struct zx_hrxml_SpeakingEvent_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpeakingEvent_DEL_Link) */

void zx_hrxml_SpeakingEvent_DEL_Link(struct zx_hrxml_SpeakingEvent_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_SpeakingEvent_GET_type) */
struct zx_str* zx_hrxml_SpeakingEvent_GET_type(struct zx_hrxml_SpeakingEvent_s* x) { return x->type; }
/* FUNC(zx_hrxml_SpeakingEvent_PUT_type) */
void zx_hrxml_SpeakingEvent_PUT_type(struct zx_hrxml_SpeakingEvent_s* x, struct zx_str* y) { x->type = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpeakingEventsHistory_NUM_SpeakingEvent) */

int zx_hrxml_SpeakingEventsHistory_NUM_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SpeakingEvent; y; ++n, y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_GET_SpeakingEvent) */

struct zx_hrxml_SpeakingEvent_s* zx_hrxml_SpeakingEventsHistory_GET_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x, int n)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x) return 0;
  for (y = x->SpeakingEvent; n>=0 && y; --n, y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_POP_SpeakingEvent) */

struct zx_hrxml_SpeakingEvent_s* zx_hrxml_SpeakingEventsHistory_POP_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x) return 0;
  y = x->SpeakingEvent;
  if (y)
    x->SpeakingEvent = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_PUSH_SpeakingEvent) */

void zx_hrxml_SpeakingEventsHistory_PUSH_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x, struct zx_hrxml_SpeakingEvent_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SpeakingEvent->gg.g;
  x->SpeakingEvent = z;
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_REV_SpeakingEvent) */

void zx_hrxml_SpeakingEventsHistory_REV_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x)
{
  struct zx_hrxml_SpeakingEvent_s* nxt;
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x) return;
  y = x->SpeakingEvent;
  if (!y) return;
  x->SpeakingEvent = 0;
  while (y) {
    nxt = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n;
    y->gg.g.n = &x->SpeakingEvent->gg.g;
    x->SpeakingEvent = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_PUT_SpeakingEvent) */

void zx_hrxml_SpeakingEventsHistory_PUT_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x, int n, struct zx_hrxml_SpeakingEvent_s* z)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x || !z) return;
  y = x->SpeakingEvent;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SpeakingEvent = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_ADD_SpeakingEvent) */

void zx_hrxml_SpeakingEventsHistory_ADD_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x, int n, struct zx_hrxml_SpeakingEvent_s* z)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SpeakingEvent->gg.g;
    x->SpeakingEvent = z;
    return;
  case -1:
    y = x->SpeakingEvent;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpeakingEvent; n > 1 && y; --n, y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpeakingEventsHistory_DEL_SpeakingEvent) */

void zx_hrxml_SpeakingEventsHistory_DEL_SpeakingEvent(struct zx_hrxml_SpeakingEventsHistory_s* x, int n)
{
  struct zx_hrxml_SpeakingEvent_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SpeakingEvent = (struct zx_hrxml_SpeakingEvent_s*)x->SpeakingEvent->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SpeakingEvent_s*)x->SpeakingEvent;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpeakingEvent; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpeakingEvent_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_NUM_CompetencyId) */

int zx_hrxml_SpecifiedCompetencyReference_NUM_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_hrxml_CompetencyId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->CompetencyId; y; ++n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_GET_CompetencyId) */

struct zx_hrxml_CompetencyId_s* zx_hrxml_SpecifiedCompetencyReference_GET_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return 0;
  for (y = x->CompetencyId; n>=0 && y; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_POP_CompetencyId) */

struct zx_hrxml_CompetencyId_s* zx_hrxml_SpecifiedCompetencyReference_POP_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return 0;
  y = x->CompetencyId;
  if (y)
    x->CompetencyId = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_PUSH_CompetencyId) */

void zx_hrxml_SpecifiedCompetencyReference_PUSH_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x, struct zx_hrxml_CompetencyId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->CompetencyId->gg.g;
  x->CompetencyId = z;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_REV_CompetencyId) */

void zx_hrxml_SpecifiedCompetencyReference_REV_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_hrxml_CompetencyId_s* nxt;
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return;
  y = x->CompetencyId;
  if (!y) return;
  x->CompetencyId = 0;
  while (y) {
    nxt = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n;
    y->gg.g.n = &x->CompetencyId->gg.g;
    x->CompetencyId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_PUT_CompetencyId) */

void zx_hrxml_SpecifiedCompetencyReference_PUT_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n, struct zx_hrxml_CompetencyId_s* z)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x || !z) return;
  y = x->CompetencyId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->CompetencyId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_ADD_CompetencyId) */

void zx_hrxml_SpecifiedCompetencyReference_ADD_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n, struct zx_hrxml_CompetencyId_s* z)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->CompetencyId->gg.g;
    x->CompetencyId = z;
    return;
  case -1:
    y = x->CompetencyId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyId; n > 1 && y; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_DEL_CompetencyId) */

void zx_hrxml_SpecifiedCompetencyReference_DEL_CompetencyId(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n)
{
  struct zx_hrxml_CompetencyId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->CompetencyId = (struct zx_hrxml_CompetencyId_s*)x->CompetencyId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_CompetencyId_s*)x->CompetencyId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->CompetencyId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_CompetencyId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_NUM_ProficencyLevel) */

int zx_hrxml_SpecifiedCompetencyReference_NUM_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProficencyLevel; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_GET_ProficencyLevel) */

struct zx_elem_s* zx_hrxml_SpecifiedCompetencyReference_GET_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ProficencyLevel; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_POP_ProficencyLevel) */

struct zx_elem_s* zx_hrxml_SpecifiedCompetencyReference_POP_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ProficencyLevel;
  if (y)
    x->ProficencyLevel = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_PUSH_ProficencyLevel) */

void zx_hrxml_SpecifiedCompetencyReference_PUSH_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ProficencyLevel->g;
  x->ProficencyLevel = z;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_REV_ProficencyLevel) */

void zx_hrxml_SpecifiedCompetencyReference_REV_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ProficencyLevel;
  if (!y) return;
  x->ProficencyLevel = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ProficencyLevel->g;
    x->ProficencyLevel = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_PUT_ProficencyLevel) */

void zx_hrxml_SpecifiedCompetencyReference_PUT_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ProficencyLevel;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ProficencyLevel = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_ADD_ProficencyLevel) */

void zx_hrxml_SpecifiedCompetencyReference_ADD_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ProficencyLevel->g;
    x->ProficencyLevel = z;
    return;
  case -1:
    y = x->ProficencyLevel;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ProficencyLevel; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SpecifiedCompetencyReference_DEL_ProficencyLevel) */

void zx_hrxml_SpecifiedCompetencyReference_DEL_ProficencyLevel(struct zx_hrxml_SpecifiedCompetencyReference_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProficencyLevel = (struct zx_elem_s*)x->ProficencyLevel->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ProficencyLevel;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ProficencyLevel; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StartDate_NUM_AnyDate) */

int zx_hrxml_StartDate_NUM_AnyDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StartDate_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_StartDate_GET_AnyDate(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StartDate_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_StartDate_POP_AnyDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StartDate_PUSH_AnyDate) */

void zx_hrxml_StartDate_PUSH_AnyDate(struct zx_hrxml_StartDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_StartDate_REV_AnyDate) */

void zx_hrxml_StartDate_REV_AnyDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StartDate_PUT_AnyDate) */

void zx_hrxml_StartDate_PUT_AnyDate(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StartDate_ADD_AnyDate) */

void zx_hrxml_StartDate_ADD_AnyDate(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StartDate_DEL_AnyDate) */

void zx_hrxml_StartDate_DEL_AnyDate(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StartDate_NUM_YearMonth) */

int zx_hrxml_StartDate_NUM_YearMonth(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StartDate_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_StartDate_GET_YearMonth(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StartDate_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_StartDate_POP_YearMonth(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StartDate_PUSH_YearMonth) */

void zx_hrxml_StartDate_PUSH_YearMonth(struct zx_hrxml_StartDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_StartDate_REV_YearMonth) */

void zx_hrxml_StartDate_REV_YearMonth(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StartDate_PUT_YearMonth) */

void zx_hrxml_StartDate_PUT_YearMonth(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StartDate_ADD_YearMonth) */

void zx_hrxml_StartDate_ADD_YearMonth(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StartDate_DEL_YearMonth) */

void zx_hrxml_StartDate_DEL_YearMonth(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StartDate_NUM_Year) */

int zx_hrxml_StartDate_NUM_Year(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StartDate_GET_Year) */

struct zx_elem_s* zx_hrxml_StartDate_GET_Year(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StartDate_POP_Year) */

struct zx_elem_s* zx_hrxml_StartDate_POP_Year(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StartDate_PUSH_Year) */

void zx_hrxml_StartDate_PUSH_Year(struct zx_hrxml_StartDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_StartDate_REV_Year) */

void zx_hrxml_StartDate_REV_Year(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StartDate_PUT_Year) */

void zx_hrxml_StartDate_PUT_Year(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StartDate_ADD_Year) */

void zx_hrxml_StartDate_ADD_Year(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StartDate_DEL_Year) */

void zx_hrxml_StartDate_DEL_Year(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StartDate_NUM_MonthDay) */

int zx_hrxml_StartDate_NUM_MonthDay(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StartDate_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_StartDate_GET_MonthDay(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StartDate_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_StartDate_POP_MonthDay(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StartDate_PUSH_MonthDay) */

void zx_hrxml_StartDate_PUSH_MonthDay(struct zx_hrxml_StartDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_StartDate_REV_MonthDay) */

void zx_hrxml_StartDate_REV_MonthDay(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StartDate_PUT_MonthDay) */

void zx_hrxml_StartDate_PUT_MonthDay(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StartDate_ADD_MonthDay) */

void zx_hrxml_StartDate_ADD_MonthDay(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StartDate_DEL_MonthDay) */

void zx_hrxml_StartDate_DEL_MonthDay(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StartDate_NUM_StringDate) */

int zx_hrxml_StartDate_NUM_StringDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StartDate_GET_StringDate) */

struct zx_elem_s* zx_hrxml_StartDate_GET_StringDate(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StartDate_POP_StringDate) */

struct zx_elem_s* zx_hrxml_StartDate_POP_StringDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StartDate_PUSH_StringDate) */

void zx_hrxml_StartDate_PUSH_StringDate(struct zx_hrxml_StartDate_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_StartDate_REV_StringDate) */

void zx_hrxml_StartDate_REV_StringDate(struct zx_hrxml_StartDate_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StartDate_PUT_StringDate) */

void zx_hrxml_StartDate_PUT_StringDate(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StartDate_ADD_StringDate) */

void zx_hrxml_StartDate_ADD_StringDate(struct zx_hrxml_StartDate_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StartDate_DEL_StringDate) */

void zx_hrxml_StartDate_DEL_StringDate(struct zx_hrxml_StartDate_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_StartDate_GET_dateDescription) */
struct zx_str* zx_hrxml_StartDate_GET_dateDescription(struct zx_hrxml_StartDate_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_StartDate_PUT_dateDescription) */
void zx_hrxml_StartDate_PUT_dateDescription(struct zx_hrxml_StartDate_s* x, struct zx_str* y) { x->dateDescription = y; }





/* FUNC(zx_hrxml_StartingCompensation_GET_currency) */
struct zx_str* zx_hrxml_StartingCompensation_GET_currency(struct zx_hrxml_StartingCompensation_s* x) { return x->currency; }
/* FUNC(zx_hrxml_StartingCompensation_PUT_currency) */
void zx_hrxml_StartingCompensation_PUT_currency(struct zx_hrxml_StartingCompensation_s* x, struct zx_str* y) { x->currency = y; }
/* FUNC(zx_hrxml_StartingCompensation_GET_intervalType) */
struct zx_str* zx_hrxml_StartingCompensation_GET_intervalType(struct zx_hrxml_StartingCompensation_s* x) { return x->intervalType; }
/* FUNC(zx_hrxml_StartingCompensation_PUT_intervalType) */
void zx_hrxml_StartingCompensation_PUT_intervalType(struct zx_hrxml_StartingCompensation_s* x, struct zx_str* y) { x->intervalType = y; }
/* FUNC(zx_hrxml_StartingCompensation_GET_validFrom) */
struct zx_str* zx_hrxml_StartingCompensation_GET_validFrom(struct zx_hrxml_StartingCompensation_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_StartingCompensation_PUT_validFrom) */
void zx_hrxml_StartingCompensation_PUT_validFrom(struct zx_hrxml_StartingCompensation_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_StartingCompensation_GET_validTo) */
struct zx_str* zx_hrxml_StartingCompensation_GET_validTo(struct zx_hrxml_StartingCompensation_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_StartingCompensation_PUT_validTo) */
void zx_hrxml_StartingCompensation_PUT_validTo(struct zx_hrxml_StartingCompensation_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_Status_GET_validFrom) */
struct zx_str* zx_hrxml_Status_GET_validFrom(struct zx_hrxml_Status_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_Status_PUT_validFrom) */
void zx_hrxml_Status_PUT_validFrom(struct zx_hrxml_Status_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_Status_GET_validTo) */
struct zx_str* zx_hrxml_Status_GET_validTo(struct zx_hrxml_Status_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_Status_PUT_validTo) */
void zx_hrxml_Status_PUT_validTo(struct zx_hrxml_Status_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Stock_NUM_Id) */

int zx_hrxml_Stock_NUM_Id(struct zx_hrxml_Stock_s* x)
{
  struct zx_hrxml_Id_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Id; y; ++n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Stock_GET_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Stock_GET_Id(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  for (y = x->Id; n>=0 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Stock_POP_Id) */

struct zx_hrxml_Id_s* zx_hrxml_Stock_POP_Id(struct zx_hrxml_Stock_s* x)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return 0;
  y = x->Id;
  if (y)
    x->Id = (struct zx_hrxml_Id_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Stock_PUSH_Id) */

void zx_hrxml_Stock_PUSH_Id(struct zx_hrxml_Stock_s* x, struct zx_hrxml_Id_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Id->gg.g;
  x->Id = z;
}

/* FUNC(zx_hrxml_Stock_REV_Id) */

void zx_hrxml_Stock_REV_Id(struct zx_hrxml_Stock_s* x)
{
  struct zx_hrxml_Id_s* nxt;
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  y = x->Id;
  if (!y) return;
  x->Id = 0;
  while (y) {
    nxt = (struct zx_hrxml_Id_s*)y->gg.g.n;
    y->gg.g.n = &x->Id->gg.g;
    x->Id = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Stock_PUT_Id) */

void zx_hrxml_Stock_PUT_Id(struct zx_hrxml_Stock_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  y = x->Id;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Id = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Stock_ADD_Id) */

void zx_hrxml_Stock_ADD_Id(struct zx_hrxml_Stock_s* x, int n, struct zx_hrxml_Id_s* z)
{
  struct zx_hrxml_Id_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Id->gg.g;
    x->Id = z;
    return;
  case -1:
    y = x->Id;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Stock_DEL_Id) */

void zx_hrxml_Stock_DEL_Id(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_hrxml_Id_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Id = (struct zx_hrxml_Id_s*)x->Id->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Id_s*)x->Id;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Id; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Id_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Stock_NUM_Symbol) */

int zx_hrxml_Stock_NUM_Symbol(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Symbol; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Stock_GET_Symbol) */

struct zx_elem_s* zx_hrxml_Stock_GET_Symbol(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Symbol; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Stock_POP_Symbol) */

struct zx_elem_s* zx_hrxml_Stock_POP_Symbol(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Symbol;
  if (y)
    x->Symbol = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Stock_PUSH_Symbol) */

void zx_hrxml_Stock_PUSH_Symbol(struct zx_hrxml_Stock_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Symbol->g;
  x->Symbol = z;
}

/* FUNC(zx_hrxml_Stock_REV_Symbol) */

void zx_hrxml_Stock_REV_Symbol(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Symbol;
  if (!y) return;
  x->Symbol = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Symbol->g;
    x->Symbol = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Stock_PUT_Symbol) */

void zx_hrxml_Stock_PUT_Symbol(struct zx_hrxml_Stock_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Symbol;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Symbol = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Stock_ADD_Symbol) */

void zx_hrxml_Stock_ADD_Symbol(struct zx_hrxml_Stock_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Symbol->g;
    x->Symbol = z;
    return;
  case -1:
    y = x->Symbol;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Symbol; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Stock_DEL_Symbol) */

void zx_hrxml_Stock_DEL_Symbol(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Symbol = (struct zx_elem_s*)x->Symbol->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Symbol;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Symbol; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Stock_NUM_Exchange) */

int zx_hrxml_Stock_NUM_Exchange(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Exchange; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Stock_GET_Exchange) */

struct zx_elem_s* zx_hrxml_Stock_GET_Exchange(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Exchange; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Stock_POP_Exchange) */

struct zx_elem_s* zx_hrxml_Stock_POP_Exchange(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Exchange;
  if (y)
    x->Exchange = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Stock_PUSH_Exchange) */

void zx_hrxml_Stock_PUSH_Exchange(struct zx_hrxml_Stock_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Exchange->g;
  x->Exchange = z;
}

/* FUNC(zx_hrxml_Stock_REV_Exchange) */

void zx_hrxml_Stock_REV_Exchange(struct zx_hrxml_Stock_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Exchange;
  if (!y) return;
  x->Exchange = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Exchange->g;
    x->Exchange = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Stock_PUT_Exchange) */

void zx_hrxml_Stock_PUT_Exchange(struct zx_hrxml_Stock_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Exchange;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Exchange = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Stock_ADD_Exchange) */

void zx_hrxml_Stock_ADD_Exchange(struct zx_hrxml_Stock_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Exchange->g;
    x->Exchange = z;
    return;
  case -1:
    y = x->Exchange;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Exchange; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Stock_DEL_Exchange) */

void zx_hrxml_Stock_DEL_Exchange(struct zx_hrxml_Stock_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Exchange = (struct zx_elem_s*)x->Exchange->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Exchange;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Exchange; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_StringValue_GET_description) */
struct zx_str* zx_hrxml_StringValue_GET_description(struct zx_hrxml_StringValue_s* x) { return x->description; }
/* FUNC(zx_hrxml_StringValue_PUT_description) */
void zx_hrxml_StringValue_PUT_description(struct zx_hrxml_StringValue_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_StringValue_GET_maxValue) */
struct zx_str* zx_hrxml_StringValue_GET_maxValue(struct zx_hrxml_StringValue_s* x) { return x->maxValue; }
/* FUNC(zx_hrxml_StringValue_PUT_maxValue) */
void zx_hrxml_StringValue_PUT_maxValue(struct zx_hrxml_StringValue_s* x, struct zx_str* y) { x->maxValue = y; }
/* FUNC(zx_hrxml_StringValue_GET_minValue) */
struct zx_str* zx_hrxml_StringValue_GET_minValue(struct zx_hrxml_StringValue_s* x) { return x->minValue; }
/* FUNC(zx_hrxml_StringValue_PUT_minValue) */
void zx_hrxml_StringValue_PUT_minValue(struct zx_hrxml_StringValue_s* x, struct zx_str* y) { x->minValue = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_ContactInfo) */

int zx_hrxml_StructuredXMLResume_NUM_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactInfo; y; ++n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_StructuredXMLResume_GET_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  for (y = x->ContactInfo; n>=0 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_StructuredXMLResume_POP_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  y = x->ContactInfo;
  if (y)
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_ContactInfo) */

void zx_hrxml_StructuredXMLResume_PUSH_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_ContactInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactInfo->gg.g;
  x->ContactInfo = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_ContactInfo) */

void zx_hrxml_StructuredXMLResume_REV_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ContactInfo_s* nxt;
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  y = x->ContactInfo;
  if (!y) return;
  x->ContactInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_ContactInfo) */

void zx_hrxml_StructuredXMLResume_PUT_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  y = x->ContactInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_ContactInfo) */

void zx_hrxml_StructuredXMLResume_ADD_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = z;
    return;
  case -1:
    y = x->ContactInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_ContactInfo) */

void zx_hrxml_StructuredXMLResume_DEL_ContactInfo(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_ExecutiveSummary) */

int zx_hrxml_StructuredXMLResume_NUM_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ExecutiveSummary; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_ExecutiveSummary) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_GET_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ExecutiveSummary; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_ExecutiveSummary) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_POP_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ExecutiveSummary;
  if (y)
    x->ExecutiveSummary = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_ExecutiveSummary) */

void zx_hrxml_StructuredXMLResume_PUSH_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ExecutiveSummary->g;
  x->ExecutiveSummary = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_ExecutiveSummary) */

void zx_hrxml_StructuredXMLResume_REV_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ExecutiveSummary;
  if (!y) return;
  x->ExecutiveSummary = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ExecutiveSummary->g;
    x->ExecutiveSummary = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_ExecutiveSummary) */

void zx_hrxml_StructuredXMLResume_PUT_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ExecutiveSummary;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ExecutiveSummary = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_ExecutiveSummary) */

void zx_hrxml_StructuredXMLResume_ADD_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ExecutiveSummary->g;
    x->ExecutiveSummary = z;
    return;
  case -1:
    y = x->ExecutiveSummary;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExecutiveSummary; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_ExecutiveSummary) */

void zx_hrxml_StructuredXMLResume_DEL_ExecutiveSummary(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ExecutiveSummary = (struct zx_elem_s*)x->ExecutiveSummary->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ExecutiveSummary;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ExecutiveSummary; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Objective) */

int zx_hrxml_StructuredXMLResume_NUM_Objective(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Objective; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Objective) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_GET_Objective(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Objective; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Objective) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_POP_Objective(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Objective;
  if (y)
    x->Objective = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Objective) */

void zx_hrxml_StructuredXMLResume_PUSH_Objective(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Objective->g;
  x->Objective = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Objective) */

void zx_hrxml_StructuredXMLResume_REV_Objective(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Objective;
  if (!y) return;
  x->Objective = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Objective->g;
    x->Objective = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Objective) */

void zx_hrxml_StructuredXMLResume_PUT_Objective(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Objective;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Objective = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Objective) */

void zx_hrxml_StructuredXMLResume_ADD_Objective(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Objective->g;
    x->Objective = z;
    return;
  case -1:
    y = x->Objective;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Objective; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Objective) */

void zx_hrxml_StructuredXMLResume_DEL_Objective(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Objective = (struct zx_elem_s*)x->Objective->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Objective;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Objective; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_EmploymentHistory) */

int zx_hrxml_StructuredXMLResume_NUM_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EmploymentHistory; y; ++n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_EmploymentHistory) */

struct zx_hrxml_EmploymentHistory_s* zx_hrxml_StructuredXMLResume_GET_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return 0;
  for (y = x->EmploymentHistory; n>=0 && y; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_EmploymentHistory) */

struct zx_hrxml_EmploymentHistory_s* zx_hrxml_StructuredXMLResume_POP_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return 0;
  y = x->EmploymentHistory;
  if (y)
    x->EmploymentHistory = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_EmploymentHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_EmploymentHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EmploymentHistory->gg.g;
  x->EmploymentHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_EmploymentHistory) */

void zx_hrxml_StructuredXMLResume_REV_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EmploymentHistory_s* nxt;
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return;
  y = x->EmploymentHistory;
  if (!y) return;
  x->EmploymentHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->EmploymentHistory->gg.g;
    x->EmploymentHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_EmploymentHistory) */

void zx_hrxml_StructuredXMLResume_PUT_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_EmploymentHistory_s* z)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x || !z) return;
  y = x->EmploymentHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EmploymentHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_EmploymentHistory) */

void zx_hrxml_StructuredXMLResume_ADD_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_EmploymentHistory_s* z)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EmploymentHistory->gg.g;
    x->EmploymentHistory = z;
    return;
  case -1:
    y = x->EmploymentHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmploymentHistory; n > 1 && y; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_EmploymentHistory) */

void zx_hrxml_StructuredXMLResume_DEL_EmploymentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_EmploymentHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EmploymentHistory = (struct zx_hrxml_EmploymentHistory_s*)x->EmploymentHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EmploymentHistory_s*)x->EmploymentHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EmploymentHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EmploymentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_EducationHistory) */

int zx_hrxml_StructuredXMLResume_NUM_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EducationHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EducationHistory; y; ++n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_EducationHistory) */

struct zx_hrxml_EducationHistory_s* zx_hrxml_StructuredXMLResume_GET_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return 0;
  for (y = x->EducationHistory; n>=0 && y; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_EducationHistory) */

struct zx_hrxml_EducationHistory_s* zx_hrxml_StructuredXMLResume_POP_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return 0;
  y = x->EducationHistory;
  if (y)
    x->EducationHistory = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_EducationHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_EducationHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EducationHistory->gg.g;
  x->EducationHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_EducationHistory) */

void zx_hrxml_StructuredXMLResume_REV_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_EducationHistory_s* nxt;
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return;
  y = x->EducationHistory;
  if (!y) return;
  x->EducationHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->EducationHistory->gg.g;
    x->EducationHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_EducationHistory) */

void zx_hrxml_StructuredXMLResume_PUT_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_EducationHistory_s* z)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x || !z) return;
  y = x->EducationHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EducationHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_EducationHistory) */

void zx_hrxml_StructuredXMLResume_ADD_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_EducationHistory_s* z)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EducationHistory->gg.g;
    x->EducationHistory = z;
    return;
  case -1:
    y = x->EducationHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationHistory; n > 1 && y; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_EducationHistory) */

void zx_hrxml_StructuredXMLResume_DEL_EducationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_EducationHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EducationHistory = (struct zx_hrxml_EducationHistory_s*)x->EducationHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EducationHistory_s*)x->EducationHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EducationHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EducationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_LicensesAndCertifications) */

int zx_hrxml_StructuredXMLResume_NUM_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->LicensesAndCertifications; y; ++n, y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_LicensesAndCertifications) */

struct zx_hrxml_LicensesAndCertifications_s* zx_hrxml_StructuredXMLResume_GET_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x) return 0;
  for (y = x->LicensesAndCertifications; n>=0 && y; --n, y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_LicensesAndCertifications) */

struct zx_hrxml_LicensesAndCertifications_s* zx_hrxml_StructuredXMLResume_POP_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x) return 0;
  y = x->LicensesAndCertifications;
  if (y)
    x->LicensesAndCertifications = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_LicensesAndCertifications) */

void zx_hrxml_StructuredXMLResume_PUSH_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_LicensesAndCertifications_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->LicensesAndCertifications->gg.g;
  x->LicensesAndCertifications = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_LicensesAndCertifications) */

void zx_hrxml_StructuredXMLResume_REV_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_LicensesAndCertifications_s* nxt;
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x) return;
  y = x->LicensesAndCertifications;
  if (!y) return;
  x->LicensesAndCertifications = 0;
  while (y) {
    nxt = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n;
    y->gg.g.n = &x->LicensesAndCertifications->gg.g;
    x->LicensesAndCertifications = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_LicensesAndCertifications) */

void zx_hrxml_StructuredXMLResume_PUT_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_LicensesAndCertifications_s* z)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x || !z) return;
  y = x->LicensesAndCertifications;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->LicensesAndCertifications = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_LicensesAndCertifications) */

void zx_hrxml_StructuredXMLResume_ADD_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_LicensesAndCertifications_s* z)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->LicensesAndCertifications->gg.g;
    x->LicensesAndCertifications = z;
    return;
  case -1:
    y = x->LicensesAndCertifications;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LicensesAndCertifications; n > 1 && y; --n, y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_LicensesAndCertifications) */

void zx_hrxml_StructuredXMLResume_DEL_LicensesAndCertifications(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_LicensesAndCertifications_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->LicensesAndCertifications = (struct zx_hrxml_LicensesAndCertifications_s*)x->LicensesAndCertifications->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_LicensesAndCertifications_s*)x->LicensesAndCertifications;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->LicensesAndCertifications; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_LicensesAndCertifications_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_MilitaryHistory) */

int zx_hrxml_StructuredXMLResume_NUM_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MilitaryHistory; y; ++n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_MilitaryHistory) */

struct zx_hrxml_MilitaryHistory_s* zx_hrxml_StructuredXMLResume_GET_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return 0;
  for (y = x->MilitaryHistory; n>=0 && y; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_MilitaryHistory) */

struct zx_hrxml_MilitaryHistory_s* zx_hrxml_StructuredXMLResume_POP_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return 0;
  y = x->MilitaryHistory;
  if (y)
    x->MilitaryHistory = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_MilitaryHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_MilitaryHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->MilitaryHistory->gg.g;
  x->MilitaryHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_MilitaryHistory) */

void zx_hrxml_StructuredXMLResume_REV_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_MilitaryHistory_s* nxt;
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return;
  y = x->MilitaryHistory;
  if (!y) return;
  x->MilitaryHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->MilitaryHistory->gg.g;
    x->MilitaryHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_MilitaryHistory) */

void zx_hrxml_StructuredXMLResume_PUT_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_MilitaryHistory_s* z)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x || !z) return;
  y = x->MilitaryHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->MilitaryHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_MilitaryHistory) */

void zx_hrxml_StructuredXMLResume_ADD_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_MilitaryHistory_s* z)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->MilitaryHistory->gg.g;
    x->MilitaryHistory = z;
    return;
  case -1:
    y = x->MilitaryHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryHistory; n > 1 && y; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_MilitaryHistory) */

void zx_hrxml_StructuredXMLResume_DEL_MilitaryHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_MilitaryHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MilitaryHistory = (struct zx_hrxml_MilitaryHistory_s*)x->MilitaryHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_MilitaryHistory_s*)x->MilitaryHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->MilitaryHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_MilitaryHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_PatentHistory) */

int zx_hrxml_StructuredXMLResume_NUM_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PatentHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PatentHistory; y; ++n, y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_PatentHistory) */

struct zx_hrxml_PatentHistory_s* zx_hrxml_StructuredXMLResume_GET_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_PatentHistory_s* y;
  if (!x) return 0;
  for (y = x->PatentHistory; n>=0 && y; --n, y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_PatentHistory) */

struct zx_hrxml_PatentHistory_s* zx_hrxml_StructuredXMLResume_POP_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PatentHistory_s* y;
  if (!x) return 0;
  y = x->PatentHistory;
  if (y)
    x->PatentHistory = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_PatentHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_PatentHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PatentHistory->gg.g;
  x->PatentHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_PatentHistory) */

void zx_hrxml_StructuredXMLResume_REV_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PatentHistory_s* nxt;
  struct zx_hrxml_PatentHistory_s* y;
  if (!x) return;
  y = x->PatentHistory;
  if (!y) return;
  x->PatentHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->PatentHistory->gg.g;
    x->PatentHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_PatentHistory) */

void zx_hrxml_StructuredXMLResume_PUT_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_PatentHistory_s* z)
{
  struct zx_hrxml_PatentHistory_s* y;
  if (!x || !z) return;
  y = x->PatentHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PatentHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_PatentHistory) */

void zx_hrxml_StructuredXMLResume_ADD_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_PatentHistory_s* z)
{
  struct zx_hrxml_PatentHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PatentHistory->gg.g;
    x->PatentHistory = z;
    return;
  case -1:
    y = x->PatentHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentHistory; n > 1 && y; --n, y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_PatentHistory) */

void zx_hrxml_StructuredXMLResume_DEL_PatentHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_PatentHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PatentHistory = (struct zx_hrxml_PatentHistory_s*)x->PatentHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PatentHistory_s*)x->PatentHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PatentHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PatentHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_PublicationHistory) */

int zx_hrxml_StructuredXMLResume_NUM_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PublicationHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PublicationHistory; y; ++n, y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_PublicationHistory) */

struct zx_hrxml_PublicationHistory_s* zx_hrxml_StructuredXMLResume_GET_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x) return 0;
  for (y = x->PublicationHistory; n>=0 && y; --n, y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_PublicationHistory) */

struct zx_hrxml_PublicationHistory_s* zx_hrxml_StructuredXMLResume_POP_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x) return 0;
  y = x->PublicationHistory;
  if (y)
    x->PublicationHistory = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_PublicationHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_PublicationHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PublicationHistory->gg.g;
  x->PublicationHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_PublicationHistory) */

void zx_hrxml_StructuredXMLResume_REV_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_PublicationHistory_s* nxt;
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x) return;
  y = x->PublicationHistory;
  if (!y) return;
  x->PublicationHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->PublicationHistory->gg.g;
    x->PublicationHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_PublicationHistory) */

void zx_hrxml_StructuredXMLResume_PUT_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_PublicationHistory_s* z)
{
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x || !z) return;
  y = x->PublicationHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PublicationHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_PublicationHistory) */

void zx_hrxml_StructuredXMLResume_ADD_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_PublicationHistory_s* z)
{
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PublicationHistory->gg.g;
    x->PublicationHistory = z;
    return;
  case -1:
    y = x->PublicationHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationHistory; n > 1 && y; --n, y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_PublicationHistory) */

void zx_hrxml_StructuredXMLResume_DEL_PublicationHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_PublicationHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PublicationHistory = (struct zx_hrxml_PublicationHistory_s*)x->PublicationHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PublicationHistory_s*)x->PublicationHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PublicationHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PublicationHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_SpeakingEventsHistory) */

int zx_hrxml_StructuredXMLResume_NUM_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SpeakingEventsHistory; y; ++n, y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_SpeakingEventsHistory) */

struct zx_hrxml_SpeakingEventsHistory_s* zx_hrxml_StructuredXMLResume_GET_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x) return 0;
  for (y = x->SpeakingEventsHistory; n>=0 && y; --n, y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_SpeakingEventsHistory) */

struct zx_hrxml_SpeakingEventsHistory_s* zx_hrxml_StructuredXMLResume_POP_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x) return 0;
  y = x->SpeakingEventsHistory;
  if (y)
    x->SpeakingEventsHistory = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_SpeakingEventsHistory) */

void zx_hrxml_StructuredXMLResume_PUSH_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_SpeakingEventsHistory_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SpeakingEventsHistory->gg.g;
  x->SpeakingEventsHistory = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_SpeakingEventsHistory) */

void zx_hrxml_StructuredXMLResume_REV_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SpeakingEventsHistory_s* nxt;
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x) return;
  y = x->SpeakingEventsHistory;
  if (!y) return;
  x->SpeakingEventsHistory = 0;
  while (y) {
    nxt = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n;
    y->gg.g.n = &x->SpeakingEventsHistory->gg.g;
    x->SpeakingEventsHistory = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_SpeakingEventsHistory) */

void zx_hrxml_StructuredXMLResume_PUT_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SpeakingEventsHistory_s* z)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x || !z) return;
  y = x->SpeakingEventsHistory;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SpeakingEventsHistory = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_SpeakingEventsHistory) */

void zx_hrxml_StructuredXMLResume_ADD_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SpeakingEventsHistory_s* z)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SpeakingEventsHistory->gg.g;
    x->SpeakingEventsHistory = z;
    return;
  case -1:
    y = x->SpeakingEventsHistory;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpeakingEventsHistory; n > 1 && y; --n, y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_SpeakingEventsHistory) */

void zx_hrxml_StructuredXMLResume_DEL_SpeakingEventsHistory(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SpeakingEventsHistory_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SpeakingEventsHistory = (struct zx_hrxml_SpeakingEventsHistory_s*)x->SpeakingEventsHistory->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SpeakingEventsHistory_s*)x->SpeakingEventsHistory;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SpeakingEventsHistory; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SpeakingEventsHistory_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Qualifications) */

int zx_hrxml_StructuredXMLResume_NUM_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Qualifications_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Qualifications; y; ++n, y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Qualifications) */

struct zx_hrxml_Qualifications_s* zx_hrxml_StructuredXMLResume_GET_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Qualifications_s* y;
  if (!x) return 0;
  for (y = x->Qualifications; n>=0 && y; --n, y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Qualifications) */

struct zx_hrxml_Qualifications_s* zx_hrxml_StructuredXMLResume_POP_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Qualifications_s* y;
  if (!x) return 0;
  y = x->Qualifications;
  if (y)
    x->Qualifications = (struct zx_hrxml_Qualifications_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Qualifications) */

void zx_hrxml_StructuredXMLResume_PUSH_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_Qualifications_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Qualifications->gg.g;
  x->Qualifications = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Qualifications) */

void zx_hrxml_StructuredXMLResume_REV_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Qualifications_s* nxt;
  struct zx_hrxml_Qualifications_s* y;
  if (!x) return;
  y = x->Qualifications;
  if (!y) return;
  x->Qualifications = 0;
  while (y) {
    nxt = (struct zx_hrxml_Qualifications_s*)y->gg.g.n;
    y->gg.g.n = &x->Qualifications->gg.g;
    x->Qualifications = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Qualifications) */

void zx_hrxml_StructuredXMLResume_PUT_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Qualifications_s* z)
{
  struct zx_hrxml_Qualifications_s* y;
  if (!x || !z) return;
  y = x->Qualifications;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Qualifications = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Qualifications) */

void zx_hrxml_StructuredXMLResume_ADD_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Qualifications_s* z)
{
  struct zx_hrxml_Qualifications_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Qualifications->gg.g;
    x->Qualifications = z;
    return;
  case -1:
    y = x->Qualifications;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Qualifications; n > 1 && y; --n, y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Qualifications) */

void zx_hrxml_StructuredXMLResume_DEL_Qualifications(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Qualifications_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Qualifications = (struct zx_hrxml_Qualifications_s*)x->Qualifications->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Qualifications_s*)x->Qualifications;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Qualifications; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Qualifications_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Languages) */

int zx_hrxml_StructuredXMLResume_NUM_Languages(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Languages_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Languages; y; ++n, y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Languages) */

struct zx_hrxml_Languages_s* zx_hrxml_StructuredXMLResume_GET_Languages(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Languages_s* y;
  if (!x) return 0;
  for (y = x->Languages; n>=0 && y; --n, y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Languages) */

struct zx_hrxml_Languages_s* zx_hrxml_StructuredXMLResume_POP_Languages(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Languages_s* y;
  if (!x) return 0;
  y = x->Languages;
  if (y)
    x->Languages = (struct zx_hrxml_Languages_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Languages) */

void zx_hrxml_StructuredXMLResume_PUSH_Languages(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_Languages_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Languages->gg.g;
  x->Languages = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Languages) */

void zx_hrxml_StructuredXMLResume_REV_Languages(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Languages_s* nxt;
  struct zx_hrxml_Languages_s* y;
  if (!x) return;
  y = x->Languages;
  if (!y) return;
  x->Languages = 0;
  while (y) {
    nxt = (struct zx_hrxml_Languages_s*)y->gg.g.n;
    y->gg.g.n = &x->Languages->gg.g;
    x->Languages = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Languages) */

void zx_hrxml_StructuredXMLResume_PUT_Languages(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Languages_s* z)
{
  struct zx_hrxml_Languages_s* y;
  if (!x || !z) return;
  y = x->Languages;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Languages = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Languages) */

void zx_hrxml_StructuredXMLResume_ADD_Languages(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Languages_s* z)
{
  struct zx_hrxml_Languages_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Languages->gg.g;
    x->Languages = z;
    return;
  case -1:
    y = x->Languages;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Languages; n > 1 && y; --n, y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Languages) */

void zx_hrxml_StructuredXMLResume_DEL_Languages(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Languages_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Languages = (struct zx_hrxml_Languages_s*)x->Languages->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Languages_s*)x->Languages;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Languages; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Languages_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Achievements) */

int zx_hrxml_StructuredXMLResume_NUM_Achievements(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Achievements_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Achievements; y; ++n, y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Achievements) */

struct zx_hrxml_Achievements_s* zx_hrxml_StructuredXMLResume_GET_Achievements(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Achievements_s* y;
  if (!x) return 0;
  for (y = x->Achievements; n>=0 && y; --n, y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Achievements) */

struct zx_hrxml_Achievements_s* zx_hrxml_StructuredXMLResume_POP_Achievements(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Achievements_s* y;
  if (!x) return 0;
  y = x->Achievements;
  if (y)
    x->Achievements = (struct zx_hrxml_Achievements_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Achievements) */

void zx_hrxml_StructuredXMLResume_PUSH_Achievements(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_Achievements_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Achievements->gg.g;
  x->Achievements = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Achievements) */

void zx_hrxml_StructuredXMLResume_REV_Achievements(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Achievements_s* nxt;
  struct zx_hrxml_Achievements_s* y;
  if (!x) return;
  y = x->Achievements;
  if (!y) return;
  x->Achievements = 0;
  while (y) {
    nxt = (struct zx_hrxml_Achievements_s*)y->gg.g.n;
    y->gg.g.n = &x->Achievements->gg.g;
    x->Achievements = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Achievements) */

void zx_hrxml_StructuredXMLResume_PUT_Achievements(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Achievements_s* z)
{
  struct zx_hrxml_Achievements_s* y;
  if (!x || !z) return;
  y = x->Achievements;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Achievements = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Achievements) */

void zx_hrxml_StructuredXMLResume_ADD_Achievements(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Achievements_s* z)
{
  struct zx_hrxml_Achievements_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Achievements->gg.g;
    x->Achievements = z;
    return;
  case -1:
    y = x->Achievements;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Achievements; n > 1 && y; --n, y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Achievements) */

void zx_hrxml_StructuredXMLResume_DEL_Achievements(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Achievements_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Achievements = (struct zx_hrxml_Achievements_s*)x->Achievements->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Achievements_s*)x->Achievements;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Achievements; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Achievements_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Associations) */

int zx_hrxml_StructuredXMLResume_NUM_Associations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Associations_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Associations; y; ++n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Associations) */

struct zx_hrxml_Associations_s* zx_hrxml_StructuredXMLResume_GET_Associations(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return 0;
  for (y = x->Associations; n>=0 && y; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Associations) */

struct zx_hrxml_Associations_s* zx_hrxml_StructuredXMLResume_POP_Associations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return 0;
  y = x->Associations;
  if (y)
    x->Associations = (struct zx_hrxml_Associations_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Associations) */

void zx_hrxml_StructuredXMLResume_PUSH_Associations(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_Associations_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Associations->gg.g;
  x->Associations = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Associations) */

void zx_hrxml_StructuredXMLResume_REV_Associations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_Associations_s* nxt;
  struct zx_hrxml_Associations_s* y;
  if (!x) return;
  y = x->Associations;
  if (!y) return;
  x->Associations = 0;
  while (y) {
    nxt = (struct zx_hrxml_Associations_s*)y->gg.g.n;
    y->gg.g.n = &x->Associations->gg.g;
    x->Associations = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Associations) */

void zx_hrxml_StructuredXMLResume_PUT_Associations(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Associations_s* z)
{
  struct zx_hrxml_Associations_s* y;
  if (!x || !z) return;
  y = x->Associations;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Associations = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Associations) */

void zx_hrxml_StructuredXMLResume_ADD_Associations(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_Associations_s* z)
{
  struct zx_hrxml_Associations_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Associations->gg.g;
    x->Associations = z;
    return;
  case -1:
    y = x->Associations;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Associations; n > 1 && y; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Associations) */

void zx_hrxml_StructuredXMLResume_DEL_Associations(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_Associations_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Associations = (struct zx_hrxml_Associations_s*)x->Associations->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Associations_s*)x->Associations;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Associations; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Associations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_References) */

int zx_hrxml_StructuredXMLResume_NUM_References(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_References_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->References; y; ++n, y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_References) */

struct zx_hrxml_References_s* zx_hrxml_StructuredXMLResume_GET_References(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_References_s* y;
  if (!x) return 0;
  for (y = x->References; n>=0 && y; --n, y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_References) */

struct zx_hrxml_References_s* zx_hrxml_StructuredXMLResume_POP_References(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_References_s* y;
  if (!x) return 0;
  y = x->References;
  if (y)
    x->References = (struct zx_hrxml_References_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_References) */

void zx_hrxml_StructuredXMLResume_PUSH_References(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_References_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->References->gg.g;
  x->References = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_References) */

void zx_hrxml_StructuredXMLResume_REV_References(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_References_s* nxt;
  struct zx_hrxml_References_s* y;
  if (!x) return;
  y = x->References;
  if (!y) return;
  x->References = 0;
  while (y) {
    nxt = (struct zx_hrxml_References_s*)y->gg.g.n;
    y->gg.g.n = &x->References->gg.g;
    x->References = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_References) */

void zx_hrxml_StructuredXMLResume_PUT_References(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_References_s* z)
{
  struct zx_hrxml_References_s* y;
  if (!x || !z) return;
  y = x->References;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->References = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_References) */

void zx_hrxml_StructuredXMLResume_ADD_References(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_References_s* z)
{
  struct zx_hrxml_References_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->References->gg.g;
    x->References = z;
    return;
  case -1:
    y = x->References;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->References; n > 1 && y; --n, y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_References) */

void zx_hrxml_StructuredXMLResume_DEL_References(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_References_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->References = (struct zx_hrxml_References_s*)x->References->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_References_s*)x->References;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->References; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_References_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_SecurityCredentials) */

int zx_hrxml_StructuredXMLResume_NUM_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SecurityCredentials; y; ++n, y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_SecurityCredentials) */

struct zx_hrxml_SecurityCredentials_s* zx_hrxml_StructuredXMLResume_GET_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x) return 0;
  for (y = x->SecurityCredentials; n>=0 && y; --n, y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_SecurityCredentials) */

struct zx_hrxml_SecurityCredentials_s* zx_hrxml_StructuredXMLResume_POP_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x) return 0;
  y = x->SecurityCredentials;
  if (y)
    x->SecurityCredentials = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_SecurityCredentials) */

void zx_hrxml_StructuredXMLResume_PUSH_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_SecurityCredentials_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SecurityCredentials->gg.g;
  x->SecurityCredentials = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_SecurityCredentials) */

void zx_hrxml_StructuredXMLResume_REV_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SecurityCredentials_s* nxt;
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x) return;
  y = x->SecurityCredentials;
  if (!y) return;
  x->SecurityCredentials = 0;
  while (y) {
    nxt = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n;
    y->gg.g.n = &x->SecurityCredentials->gg.g;
    x->SecurityCredentials = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_SecurityCredentials) */

void zx_hrxml_StructuredXMLResume_PUT_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SecurityCredentials_s* z)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x || !z) return;
  y = x->SecurityCredentials;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SecurityCredentials = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_SecurityCredentials) */

void zx_hrxml_StructuredXMLResume_ADD_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SecurityCredentials_s* z)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SecurityCredentials->gg.g;
    x->SecurityCredentials = z;
    return;
  case -1:
    y = x->SecurityCredentials;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SecurityCredentials; n > 1 && y; --n, y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_SecurityCredentials) */

void zx_hrxml_StructuredXMLResume_DEL_SecurityCredentials(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SecurityCredentials_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SecurityCredentials = (struct zx_hrxml_SecurityCredentials_s*)x->SecurityCredentials->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SecurityCredentials_s*)x->SecurityCredentials;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SecurityCredentials; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SecurityCredentials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_ResumeAdditionalItems) */

int zx_hrxml_StructuredXMLResume_NUM_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ResumeAdditionalItems; y; ++n, y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_ResumeAdditionalItems) */

struct zx_hrxml_ResumeAdditionalItems_s* zx_hrxml_StructuredXMLResume_GET_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x) return 0;
  for (y = x->ResumeAdditionalItems; n>=0 && y; --n, y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_ResumeAdditionalItems) */

struct zx_hrxml_ResumeAdditionalItems_s* zx_hrxml_StructuredXMLResume_POP_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x) return 0;
  y = x->ResumeAdditionalItems;
  if (y)
    x->ResumeAdditionalItems = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_ResumeAdditionalItems) */

void zx_hrxml_StructuredXMLResume_PUSH_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_ResumeAdditionalItems_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ResumeAdditionalItems->gg.g;
  x->ResumeAdditionalItems = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_ResumeAdditionalItems) */

void zx_hrxml_StructuredXMLResume_REV_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ResumeAdditionalItems_s* nxt;
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x) return;
  y = x->ResumeAdditionalItems;
  if (!y) return;
  x->ResumeAdditionalItems = 0;
  while (y) {
    nxt = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n;
    y->gg.g.n = &x->ResumeAdditionalItems->gg.g;
    x->ResumeAdditionalItems = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_ResumeAdditionalItems) */

void zx_hrxml_StructuredXMLResume_PUT_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ResumeAdditionalItems_s* z)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x || !z) return;
  y = x->ResumeAdditionalItems;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ResumeAdditionalItems = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_ResumeAdditionalItems) */

void zx_hrxml_StructuredXMLResume_ADD_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ResumeAdditionalItems_s* z)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ResumeAdditionalItems->gg.g;
    x->ResumeAdditionalItems = z;
    return;
  case -1:
    y = x->ResumeAdditionalItems;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ResumeAdditionalItems; n > 1 && y; --n, y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_ResumeAdditionalItems) */

void zx_hrxml_StructuredXMLResume_DEL_ResumeAdditionalItems(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ResumeAdditionalItems_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ResumeAdditionalItems = (struct zx_hrxml_ResumeAdditionalItems_s*)x->ResumeAdditionalItems->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ResumeAdditionalItems_s*)x->ResumeAdditionalItems;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ResumeAdditionalItems; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ResumeAdditionalItems_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_SupportingMaterials) */

int zx_hrxml_StructuredXMLResume_NUM_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->SupportingMaterials; y; ++n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_StructuredXMLResume_GET_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  for (y = x->SupportingMaterials; n>=0 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_SupportingMaterials) */

struct zx_hrxml_SupportingMaterials_s* zx_hrxml_StructuredXMLResume_POP_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return 0;
  y = x->SupportingMaterials;
  if (y)
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_SupportingMaterials) */

void zx_hrxml_StructuredXMLResume_PUSH_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_SupportingMaterials_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->SupportingMaterials->gg.g;
  x->SupportingMaterials = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_SupportingMaterials) */

void zx_hrxml_StructuredXMLResume_REV_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_SupportingMaterials_s* nxt;
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  y = x->SupportingMaterials;
  if (!y) return;
  x->SupportingMaterials = 0;
  while (y) {
    nxt = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n;
    y->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_SupportingMaterials) */

void zx_hrxml_StructuredXMLResume_PUT_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  y = x->SupportingMaterials;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->SupportingMaterials = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_SupportingMaterials) */

void zx_hrxml_StructuredXMLResume_ADD_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_SupportingMaterials_s* z)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->SupportingMaterials->gg.g;
    x->SupportingMaterials = z;
    return;
  case -1:
    y = x->SupportingMaterials;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_SupportingMaterials) */

void zx_hrxml_StructuredXMLResume_DEL_SupportingMaterials(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_SupportingMaterials_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->SupportingMaterials = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_SupportingMaterials_s*)x->SupportingMaterials;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->SupportingMaterials; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_SupportingMaterials_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_ProfessionalAssociations) */

int zx_hrxml_StructuredXMLResume_NUM_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ProfessionalAssociations; y; ++n, y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_ProfessionalAssociations) */

struct zx_hrxml_ProfessionalAssociations_s* zx_hrxml_StructuredXMLResume_GET_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x) return 0;
  for (y = x->ProfessionalAssociations; n>=0 && y; --n, y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_ProfessionalAssociations) */

struct zx_hrxml_ProfessionalAssociations_s* zx_hrxml_StructuredXMLResume_POP_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x) return 0;
  y = x->ProfessionalAssociations;
  if (y)
    x->ProfessionalAssociations = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_ProfessionalAssociations) */

void zx_hrxml_StructuredXMLResume_PUSH_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_hrxml_ProfessionalAssociations_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ProfessionalAssociations->gg.g;
  x->ProfessionalAssociations = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_ProfessionalAssociations) */

void zx_hrxml_StructuredXMLResume_REV_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_hrxml_ProfessionalAssociations_s* nxt;
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x) return;
  y = x->ProfessionalAssociations;
  if (!y) return;
  x->ProfessionalAssociations = 0;
  while (y) {
    nxt = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n;
    y->gg.g.n = &x->ProfessionalAssociations->gg.g;
    x->ProfessionalAssociations = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_ProfessionalAssociations) */

void zx_hrxml_StructuredXMLResume_PUT_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ProfessionalAssociations_s* z)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x || !z) return;
  y = x->ProfessionalAssociations;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ProfessionalAssociations = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_ProfessionalAssociations) */

void zx_hrxml_StructuredXMLResume_ADD_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_hrxml_ProfessionalAssociations_s* z)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ProfessionalAssociations->gg.g;
    x->ProfessionalAssociations = z;
    return;
  case -1:
    y = x->ProfessionalAssociations;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProfessionalAssociations; n > 1 && y; --n, y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_ProfessionalAssociations) */

void zx_hrxml_StructuredXMLResume_DEL_ProfessionalAssociations(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_hrxml_ProfessionalAssociations_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ProfessionalAssociations = (struct zx_hrxml_ProfessionalAssociations_s*)x->ProfessionalAssociations->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ProfessionalAssociations_s*)x->ProfessionalAssociations;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ProfessionalAssociations; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ProfessionalAssociations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_Comments) */

int zx_hrxml_StructuredXMLResume_NUM_Comments(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Comments; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_Comments) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_GET_Comments(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Comments; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_Comments) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_POP_Comments(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Comments;
  if (y)
    x->Comments = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_Comments) */

void zx_hrxml_StructuredXMLResume_PUSH_Comments(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Comments->g;
  x->Comments = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_Comments) */

void zx_hrxml_StructuredXMLResume_REV_Comments(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Comments;
  if (!y) return;
  x->Comments = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Comments->g;
    x->Comments = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_Comments) */

void zx_hrxml_StructuredXMLResume_PUT_Comments(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Comments;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Comments = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_Comments) */

void zx_hrxml_StructuredXMLResume_ADD_Comments(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Comments->g;
    x->Comments = z;
    return;
  case -1:
    y = x->Comments;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_Comments) */

void zx_hrxml_StructuredXMLResume_DEL_Comments(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Comments = (struct zx_elem_s*)x->Comments->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Comments;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Comments; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_StructuredXMLResume_NUM_RevisionDate) */

int zx_hrxml_StructuredXMLResume_NUM_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->RevisionDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_StructuredXMLResume_GET_RevisionDate) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_GET_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->RevisionDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_POP_RevisionDate) */

struct zx_elem_s* zx_hrxml_StructuredXMLResume_POP_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->RevisionDate;
  if (y)
    x->RevisionDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUSH_RevisionDate) */

void zx_hrxml_StructuredXMLResume_PUSH_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->RevisionDate->g;
  x->RevisionDate = z;
}

/* FUNC(zx_hrxml_StructuredXMLResume_REV_RevisionDate) */

void zx_hrxml_StructuredXMLResume_REV_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->RevisionDate;
  if (!y) return;
  x->RevisionDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->RevisionDate->g;
    x->RevisionDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_PUT_RevisionDate) */

void zx_hrxml_StructuredXMLResume_PUT_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->RevisionDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->RevisionDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_StructuredXMLResume_ADD_RevisionDate) */

void zx_hrxml_StructuredXMLResume_ADD_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->RevisionDate->g;
    x->RevisionDate = z;
    return;
  case -1:
    y = x->RevisionDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RevisionDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_StructuredXMLResume_DEL_RevisionDate) */

void zx_hrxml_StructuredXMLResume_DEL_RevisionDate(struct zx_hrxml_StructuredXMLResume_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->RevisionDate = (struct zx_elem_s*)x->RevisionDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->RevisionDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->RevisionDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SupplierId_NUM_IdValue) */

int zx_hrxml_SupplierId_NUM_IdValue(struct zx_hrxml_SupplierId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SupplierId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SupplierId_GET_IdValue(struct zx_hrxml_SupplierId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SupplierId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_SupplierId_POP_IdValue(struct zx_hrxml_SupplierId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SupplierId_PUSH_IdValue) */

void zx_hrxml_SupplierId_PUSH_IdValue(struct zx_hrxml_SupplierId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_SupplierId_REV_IdValue) */

void zx_hrxml_SupplierId_REV_IdValue(struct zx_hrxml_SupplierId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SupplierId_PUT_IdValue) */

void zx_hrxml_SupplierId_PUT_IdValue(struct zx_hrxml_SupplierId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SupplierId_ADD_IdValue) */

void zx_hrxml_SupplierId_ADD_IdValue(struct zx_hrxml_SupplierId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SupplierId_DEL_IdValue) */

void zx_hrxml_SupplierId_DEL_IdValue(struct zx_hrxml_SupplierId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_SupplierId_GET_idOwner) */
struct zx_str* zx_hrxml_SupplierId_GET_idOwner(struct zx_hrxml_SupplierId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_SupplierId_PUT_idOwner) */
void zx_hrxml_SupplierId_PUT_idOwner(struct zx_hrxml_SupplierId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_SupplierId_GET_validFrom) */
struct zx_str* zx_hrxml_SupplierId_GET_validFrom(struct zx_hrxml_SupplierId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_SupplierId_PUT_validFrom) */
void zx_hrxml_SupplierId_PUT_validFrom(struct zx_hrxml_SupplierId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_SupplierId_GET_validTo) */
struct zx_str* zx_hrxml_SupplierId_GET_validTo(struct zx_hrxml_SupplierId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_SupplierId_PUT_validTo) */
void zx_hrxml_SupplierId_PUT_validTo(struct zx_hrxml_SupplierId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SupportingMaterials_NUM_Link) */

int zx_hrxml_SupportingMaterials_NUM_Link(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Link; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SupportingMaterials_GET_Link) */

struct zx_elem_s* zx_hrxml_SupportingMaterials_GET_Link(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Link; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_POP_Link) */

struct zx_elem_s* zx_hrxml_SupportingMaterials_POP_Link(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Link;
  if (y)
    x->Link = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_PUSH_Link) */

void zx_hrxml_SupportingMaterials_PUSH_Link(struct zx_hrxml_SupportingMaterials_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Link->g;
  x->Link = z;
}

/* FUNC(zx_hrxml_SupportingMaterials_REV_Link) */

void zx_hrxml_SupportingMaterials_REV_Link(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Link;
  if (!y) return;
  x->Link = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Link->g;
    x->Link = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_PUT_Link) */

void zx_hrxml_SupportingMaterials_PUT_Link(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Link;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Link = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_ADD_Link) */

void zx_hrxml_SupportingMaterials_ADD_Link(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Link->g;
    x->Link = z;
    return;
  case -1:
    y = x->Link;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_SupportingMaterials_DEL_Link) */

void zx_hrxml_SupportingMaterials_DEL_Link(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Link = (struct zx_elem_s*)x->Link->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Link;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Link; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SupportingMaterials_NUM_AttachmentReference) */

int zx_hrxml_SupportingMaterials_NUM_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_AttachmentReference_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AttachmentReference; y; ++n, y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SupportingMaterials_GET_AttachmentReference) */

struct zx_hrxml_AttachmentReference_s* zx_hrxml_SupportingMaterials_GET_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x) return 0;
  for (y = x->AttachmentReference; n>=0 && y; --n, y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_POP_AttachmentReference) */

struct zx_hrxml_AttachmentReference_s* zx_hrxml_SupportingMaterials_POP_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x) return 0;
  y = x->AttachmentReference;
  if (y)
    x->AttachmentReference = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_PUSH_AttachmentReference) */

void zx_hrxml_SupportingMaterials_PUSH_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x, struct zx_hrxml_AttachmentReference_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->AttachmentReference->gg.g;
  x->AttachmentReference = z;
}

/* FUNC(zx_hrxml_SupportingMaterials_REV_AttachmentReference) */

void zx_hrxml_SupportingMaterials_REV_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_AttachmentReference_s* nxt;
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x) return;
  y = x->AttachmentReference;
  if (!y) return;
  x->AttachmentReference = 0;
  while (y) {
    nxt = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n;
    y->gg.g.n = &x->AttachmentReference->gg.g;
    x->AttachmentReference = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_PUT_AttachmentReference) */

void zx_hrxml_SupportingMaterials_PUT_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_hrxml_AttachmentReference_s* z)
{
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x || !z) return;
  y = x->AttachmentReference;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->AttachmentReference = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_ADD_AttachmentReference) */

void zx_hrxml_SupportingMaterials_ADD_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_hrxml_AttachmentReference_s* z)
{
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->AttachmentReference->gg.g;
    x->AttachmentReference = z;
    return;
  case -1:
    y = x->AttachmentReference;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AttachmentReference; n > 1 && y; --n, y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SupportingMaterials_DEL_AttachmentReference) */

void zx_hrxml_SupportingMaterials_DEL_AttachmentReference(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_hrxml_AttachmentReference_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AttachmentReference = (struct zx_hrxml_AttachmentReference_s*)x->AttachmentReference->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_AttachmentReference_s*)x->AttachmentReference;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->AttachmentReference; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_AttachmentReference_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_SupportingMaterials_NUM_Description) */

int zx_hrxml_SupportingMaterials_NUM_Description(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_SupportingMaterials_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SupportingMaterials_GET_Description(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_SupportingMaterials_POP_Description(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_SupportingMaterials_PUSH_Description) */

void zx_hrxml_SupportingMaterials_PUSH_Description(struct zx_hrxml_SupportingMaterials_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_SupportingMaterials_REV_Description) */

void zx_hrxml_SupportingMaterials_REV_Description(struct zx_hrxml_SupportingMaterials_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_PUT_Description) */

void zx_hrxml_SupportingMaterials_PUT_Description(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_SupportingMaterials_ADD_Description) */

void zx_hrxml_SupportingMaterials_ADD_Description(struct zx_hrxml_SupportingMaterials_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_SupportingMaterials_DEL_Description) */

void zx_hrxml_SupportingMaterials_DEL_Description(struct zx_hrxml_SupportingMaterials_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_TTYTDD_NUM_FormattedNumber) */

int zx_hrxml_TTYTDD_NUM_FormattedNumber(struct zx_hrxml_TTYTDD_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_TTYTDD_GET_FormattedNumber) */

struct zx_elem_s* zx_hrxml_TTYTDD_GET_FormattedNumber(struct zx_hrxml_TTYTDD_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_TTYTDD_POP_FormattedNumber) */

struct zx_elem_s* zx_hrxml_TTYTDD_POP_FormattedNumber(struct zx_hrxml_TTYTDD_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedNumber;
  if (y)
    x->FormattedNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_TTYTDD_PUSH_FormattedNumber) */

void zx_hrxml_TTYTDD_PUSH_FormattedNumber(struct zx_hrxml_TTYTDD_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedNumber->g;
  x->FormattedNumber = z;
}

/* FUNC(zx_hrxml_TTYTDD_REV_FormattedNumber) */

void zx_hrxml_TTYTDD_REV_FormattedNumber(struct zx_hrxml_TTYTDD_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedNumber;
  if (!y) return;
  x->FormattedNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_TTYTDD_PUT_FormattedNumber) */

void zx_hrxml_TTYTDD_PUT_FormattedNumber(struct zx_hrxml_TTYTDD_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_TTYTDD_ADD_FormattedNumber) */

void zx_hrxml_TTYTDD_ADD_FormattedNumber(struct zx_hrxml_TTYTDD_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = z;
    return;
  case -1:
    y = x->FormattedNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_TTYTDD_DEL_FormattedNumber) */

void zx_hrxml_TTYTDD_DEL_FormattedNumber(struct zx_hrxml_TTYTDD_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedNumber = (struct zx_elem_s*)x->FormattedNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_TaxId_NUM_IdValue) */

int zx_hrxml_TaxId_NUM_IdValue(struct zx_hrxml_TaxId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_TaxId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_TaxId_GET_IdValue(struct zx_hrxml_TaxId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_TaxId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_TaxId_POP_IdValue(struct zx_hrxml_TaxId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_TaxId_PUSH_IdValue) */

void zx_hrxml_TaxId_PUSH_IdValue(struct zx_hrxml_TaxId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_TaxId_REV_IdValue) */

void zx_hrxml_TaxId_REV_IdValue(struct zx_hrxml_TaxId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_TaxId_PUT_IdValue) */

void zx_hrxml_TaxId_PUT_IdValue(struct zx_hrxml_TaxId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_TaxId_ADD_IdValue) */

void zx_hrxml_TaxId_ADD_IdValue(struct zx_hrxml_TaxId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_TaxId_DEL_IdValue) */

void zx_hrxml_TaxId_DEL_IdValue(struct zx_hrxml_TaxId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_TaxId_GET_idOwner) */
struct zx_str* zx_hrxml_TaxId_GET_idOwner(struct zx_hrxml_TaxId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_TaxId_PUT_idOwner) */
void zx_hrxml_TaxId_PUT_idOwner(struct zx_hrxml_TaxId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_TaxId_GET_validFrom) */
struct zx_str* zx_hrxml_TaxId_GET_validFrom(struct zx_hrxml_TaxId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_TaxId_PUT_validFrom) */
void zx_hrxml_TaxId_PUT_validFrom(struct zx_hrxml_TaxId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_TaxId_GET_validTo) */
struct zx_str* zx_hrxml_TaxId_GET_validTo(struct zx_hrxml_TaxId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_TaxId_PUT_validTo) */
void zx_hrxml_TaxId_PUT_validTo(struct zx_hrxml_TaxId_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_TaxonomyId_GET_description) */
struct zx_str* zx_hrxml_TaxonomyId_GET_description(struct zx_hrxml_TaxonomyId_s* x) { return x->description; }
/* FUNC(zx_hrxml_TaxonomyId_PUT_description) */
void zx_hrxml_TaxonomyId_PUT_description(struct zx_hrxml_TaxonomyId_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_TaxonomyId_GET_id) */
struct zx_str* zx_hrxml_TaxonomyId_GET_id(struct zx_hrxml_TaxonomyId_s* x) { return x->id; }
/* FUNC(zx_hrxml_TaxonomyId_PUT_id) */
void zx_hrxml_TaxonomyId_PUT_id(struct zx_hrxml_TaxonomyId_s* x, struct zx_str* y) { x->id = y; }
/* FUNC(zx_hrxml_TaxonomyId_GET_idOwner) */
struct zx_str* zx_hrxml_TaxonomyId_GET_idOwner(struct zx_hrxml_TaxonomyId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_TaxonomyId_PUT_idOwner) */
void zx_hrxml_TaxonomyId_PUT_idOwner(struct zx_hrxml_TaxonomyId_s* x, struct zx_str* y) { x->idOwner = y; }





/* FUNC(zx_hrxml_TaxonomyName_GET_version) */
struct zx_str* zx_hrxml_TaxonomyName_GET_version(struct zx_hrxml_TaxonomyName_s* x) { return x->version; }
/* FUNC(zx_hrxml_TaxonomyName_PUT_version) */
void zx_hrxml_TaxonomyName_PUT_version(struct zx_hrxml_TaxonomyName_s* x, struct zx_str* y) { x->version = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Telephone_NUM_FormattedNumber) */

int zx_hrxml_Telephone_NUM_FormattedNumber(struct zx_hrxml_Telephone_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->FormattedNumber; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Telephone_GET_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Telephone_GET_FormattedNumber(struct zx_hrxml_Telephone_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->FormattedNumber; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Telephone_POP_FormattedNumber) */

struct zx_elem_s* zx_hrxml_Telephone_POP_FormattedNumber(struct zx_hrxml_Telephone_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->FormattedNumber;
  if (y)
    x->FormattedNumber = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Telephone_PUSH_FormattedNumber) */

void zx_hrxml_Telephone_PUSH_FormattedNumber(struct zx_hrxml_Telephone_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->FormattedNumber->g;
  x->FormattedNumber = z;
}

/* FUNC(zx_hrxml_Telephone_REV_FormattedNumber) */

void zx_hrxml_Telephone_REV_FormattedNumber(struct zx_hrxml_Telephone_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->FormattedNumber;
  if (!y) return;
  x->FormattedNumber = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Telephone_PUT_FormattedNumber) */

void zx_hrxml_Telephone_PUT_FormattedNumber(struct zx_hrxml_Telephone_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->FormattedNumber;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->FormattedNumber = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Telephone_ADD_FormattedNumber) */

void zx_hrxml_Telephone_ADD_FormattedNumber(struct zx_hrxml_Telephone_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->FormattedNumber->g;
    x->FormattedNumber = z;
    return;
  case -1:
    y = x->FormattedNumber;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Telephone_DEL_FormattedNumber) */

void zx_hrxml_Telephone_DEL_FormattedNumber(struct zx_hrxml_Telephone_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->FormattedNumber = (struct zx_elem_s*)x->FormattedNumber->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->FormattedNumber;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->FormattedNumber; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_TermOfNotice_NUM_Value) */

int zx_hrxml_TermOfNotice_NUM_Value(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Value; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_TermOfNotice_GET_Value) */

struct zx_elem_s* zx_hrxml_TermOfNotice_GET_Value(struct zx_hrxml_TermOfNotice_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Value; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_TermOfNotice_POP_Value) */

struct zx_elem_s* zx_hrxml_TermOfNotice_POP_Value(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Value;
  if (y)
    x->Value = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_TermOfNotice_PUSH_Value) */

void zx_hrxml_TermOfNotice_PUSH_Value(struct zx_hrxml_TermOfNotice_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Value->g;
  x->Value = z;
}

/* FUNC(zx_hrxml_TermOfNotice_REV_Value) */

void zx_hrxml_TermOfNotice_REV_Value(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Value;
  if (!y) return;
  x->Value = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Value->g;
    x->Value = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_TermOfNotice_PUT_Value) */

void zx_hrxml_TermOfNotice_PUT_Value(struct zx_hrxml_TermOfNotice_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Value;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Value = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_TermOfNotice_ADD_Value) */

void zx_hrxml_TermOfNotice_ADD_Value(struct zx_hrxml_TermOfNotice_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Value->g;
    x->Value = z;
    return;
  case -1:
    y = x->Value;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_TermOfNotice_DEL_Value) */

void zx_hrxml_TermOfNotice_DEL_Value(struct zx_hrxml_TermOfNotice_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Value = (struct zx_elem_s*)x->Value->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Value;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Value; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_TermOfNotice_NUM_Interval) */

int zx_hrxml_TermOfNotice_NUM_Interval(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Interval; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_TermOfNotice_GET_Interval) */

struct zx_elem_s* zx_hrxml_TermOfNotice_GET_Interval(struct zx_hrxml_TermOfNotice_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Interval; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_TermOfNotice_POP_Interval) */

struct zx_elem_s* zx_hrxml_TermOfNotice_POP_Interval(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Interval;
  if (y)
    x->Interval = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_TermOfNotice_PUSH_Interval) */

void zx_hrxml_TermOfNotice_PUSH_Interval(struct zx_hrxml_TermOfNotice_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Interval->g;
  x->Interval = z;
}

/* FUNC(zx_hrxml_TermOfNotice_REV_Interval) */

void zx_hrxml_TermOfNotice_REV_Interval(struct zx_hrxml_TermOfNotice_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Interval;
  if (!y) return;
  x->Interval = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Interval->g;
    x->Interval = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_TermOfNotice_PUT_Interval) */

void zx_hrxml_TermOfNotice_PUT_Interval(struct zx_hrxml_TermOfNotice_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Interval;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Interval = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_TermOfNotice_ADD_Interval) */

void zx_hrxml_TermOfNotice_ADD_Interval(struct zx_hrxml_TermOfNotice_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Interval->g;
    x->Interval = z;
    return;
  case -1:
    y = x->Interval;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Interval; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_TermOfNotice_DEL_Interval) */

void zx_hrxml_TermOfNotice_DEL_Interval(struct zx_hrxml_TermOfNotice_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Interval = (struct zx_elem_s*)x->Interval->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Interval;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Interval; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_TimeMax_GET_unitOfMeasure) */
struct zx_str* zx_hrxml_TimeMax_GET_unitOfMeasure(struct zx_hrxml_TimeMax_s* x) { return x->unitOfMeasure; }
/* FUNC(zx_hrxml_TimeMax_PUT_unitOfMeasure) */
void zx_hrxml_TimeMax_PUT_unitOfMeasure(struct zx_hrxml_TimeMax_s* x, struct zx_str* y) { x->unitOfMeasure = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_TimeOffAllowance_NUM_Description) */

int zx_hrxml_TimeOffAllowance_NUM_Description(struct zx_hrxml_TimeOffAllowance_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_TimeOffAllowance_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_TimeOffAllowance_GET_Description(struct zx_hrxml_TimeOffAllowance_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_TimeOffAllowance_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_TimeOffAllowance_POP_Description(struct zx_hrxml_TimeOffAllowance_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_TimeOffAllowance_PUSH_Description) */

void zx_hrxml_TimeOffAllowance_PUSH_Description(struct zx_hrxml_TimeOffAllowance_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_TimeOffAllowance_REV_Description) */

void zx_hrxml_TimeOffAllowance_REV_Description(struct zx_hrxml_TimeOffAllowance_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_TimeOffAllowance_PUT_Description) */

void zx_hrxml_TimeOffAllowance_PUT_Description(struct zx_hrxml_TimeOffAllowance_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_TimeOffAllowance_ADD_Description) */

void zx_hrxml_TimeOffAllowance_ADD_Description(struct zx_hrxml_TimeOffAllowance_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_TimeOffAllowance_DEL_Description) */

void zx_hrxml_TimeOffAllowance_DEL_Description(struct zx_hrxml_TimeOffAllowance_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_TimeOffAllowance_GET_timeOffType) */
struct zx_str* zx_hrxml_TimeOffAllowance_GET_timeOffType(struct zx_hrxml_TimeOffAllowance_s* x) { return x->timeOffType; }
/* FUNC(zx_hrxml_TimeOffAllowance_PUT_timeOffType) */
void zx_hrxml_TimeOffAllowance_PUT_timeOffType(struct zx_hrxml_TimeOffAllowance_s* x, struct zx_str* y) { x->timeOffType = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Travel_NUM_Applicable) */

int zx_hrxml_Travel_NUM_Applicable(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Applicable; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Travel_GET_Applicable) */

struct zx_elem_s* zx_hrxml_Travel_GET_Applicable(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Applicable; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Travel_POP_Applicable) */

struct zx_elem_s* zx_hrxml_Travel_POP_Applicable(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Applicable;
  if (y)
    x->Applicable = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Travel_PUSH_Applicable) */

void zx_hrxml_Travel_PUSH_Applicable(struct zx_hrxml_Travel_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Applicable->g;
  x->Applicable = z;
}

/* FUNC(zx_hrxml_Travel_REV_Applicable) */

void zx_hrxml_Travel_REV_Applicable(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Applicable;
  if (!y) return;
  x->Applicable = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Applicable->g;
    x->Applicable = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Travel_PUT_Applicable) */

void zx_hrxml_Travel_PUT_Applicable(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Applicable;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Applicable = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Travel_ADD_Applicable) */

void zx_hrxml_Travel_ADD_Applicable(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Applicable->g;
    x->Applicable = z;
    return;
  case -1:
    y = x->Applicable;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Applicable; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Travel_DEL_Applicable) */

void zx_hrxml_Travel_DEL_Applicable(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Applicable = (struct zx_elem_s*)x->Applicable->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Applicable;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Applicable; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Travel_NUM_TravelFrequency) */

int zx_hrxml_Travel_NUM_TravelFrequency(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TravelFrequency; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Travel_GET_TravelFrequency) */

struct zx_elem_s* zx_hrxml_Travel_GET_TravelFrequency(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->TravelFrequency; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Travel_POP_TravelFrequency) */

struct zx_elem_s* zx_hrxml_Travel_POP_TravelFrequency(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->TravelFrequency;
  if (y)
    x->TravelFrequency = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Travel_PUSH_TravelFrequency) */

void zx_hrxml_Travel_PUSH_TravelFrequency(struct zx_hrxml_Travel_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->TravelFrequency->g;
  x->TravelFrequency = z;
}

/* FUNC(zx_hrxml_Travel_REV_TravelFrequency) */

void zx_hrxml_Travel_REV_TravelFrequency(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->TravelFrequency;
  if (!y) return;
  x->TravelFrequency = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->TravelFrequency->g;
    x->TravelFrequency = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Travel_PUT_TravelFrequency) */

void zx_hrxml_Travel_PUT_TravelFrequency(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->TravelFrequency;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->TravelFrequency = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Travel_ADD_TravelFrequency) */

void zx_hrxml_Travel_ADD_TravelFrequency(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->TravelFrequency->g;
    x->TravelFrequency = z;
    return;
  case -1:
    y = x->TravelFrequency;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TravelFrequency; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Travel_DEL_TravelFrequency) */

void zx_hrxml_Travel_DEL_TravelFrequency(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TravelFrequency = (struct zx_elem_s*)x->TravelFrequency->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->TravelFrequency;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TravelFrequency; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Travel_NUM_TravelConsiderations) */

int zx_hrxml_Travel_NUM_TravelConsiderations(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TravelConsiderations; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Travel_GET_TravelConsiderations) */

struct zx_elem_s* zx_hrxml_Travel_GET_TravelConsiderations(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->TravelConsiderations; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Travel_POP_TravelConsiderations) */

struct zx_elem_s* zx_hrxml_Travel_POP_TravelConsiderations(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->TravelConsiderations;
  if (y)
    x->TravelConsiderations = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Travel_PUSH_TravelConsiderations) */

void zx_hrxml_Travel_PUSH_TravelConsiderations(struct zx_hrxml_Travel_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->TravelConsiderations->g;
  x->TravelConsiderations = z;
}

/* FUNC(zx_hrxml_Travel_REV_TravelConsiderations) */

void zx_hrxml_Travel_REV_TravelConsiderations(struct zx_hrxml_Travel_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->TravelConsiderations;
  if (!y) return;
  x->TravelConsiderations = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->TravelConsiderations->g;
    x->TravelConsiderations = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Travel_PUT_TravelConsiderations) */

void zx_hrxml_Travel_PUT_TravelConsiderations(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->TravelConsiderations;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->TravelConsiderations = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Travel_ADD_TravelConsiderations) */

void zx_hrxml_Travel_ADD_TravelConsiderations(struct zx_hrxml_Travel_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->TravelConsiderations->g;
    x->TravelConsiderations = z;
    return;
  case -1:
    y = x->TravelConsiderations;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TravelConsiderations; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Travel_DEL_TravelConsiderations) */

void zx_hrxml_Travel_DEL_TravelConsiderations(struct zx_hrxml_Travel_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TravelConsiderations = (struct zx_elem_s*)x->TravelConsiderations->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->TravelConsiderations;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->TravelConsiderations; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif






/* FUNC(zx_hrxml_TravelDirections_GET_lang) */
struct zx_str* zx_hrxml_TravelDirections_GET_lang(struct zx_hrxml_TravelDirections_s* x) { return x->lang; }
/* FUNC(zx_hrxml_TravelDirections_PUT_lang) */
void zx_hrxml_TravelDirections_PUT_lang(struct zx_hrxml_TravelDirections_s* x, struct zx_str* y) { x->lang = y; }












#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_UserId_NUM_IdValue) */

int zx_hrxml_UserId_NUM_IdValue(struct zx_hrxml_UserId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_UserId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_UserId_GET_IdValue(struct zx_hrxml_UserId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_UserId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_UserId_POP_IdValue(struct zx_hrxml_UserId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_UserId_PUSH_IdValue) */

void zx_hrxml_UserId_PUSH_IdValue(struct zx_hrxml_UserId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_UserId_REV_IdValue) */

void zx_hrxml_UserId_REV_IdValue(struct zx_hrxml_UserId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_UserId_PUT_IdValue) */

void zx_hrxml_UserId_PUT_IdValue(struct zx_hrxml_UserId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_UserId_ADD_IdValue) */

void zx_hrxml_UserId_ADD_IdValue(struct zx_hrxml_UserId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_UserId_DEL_IdValue) */

void zx_hrxml_UserId_DEL_IdValue(struct zx_hrxml_UserId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_UserId_GET_idOwner) */
struct zx_str* zx_hrxml_UserId_GET_idOwner(struct zx_hrxml_UserId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_UserId_PUT_idOwner) */
void zx_hrxml_UserId_PUT_idOwner(struct zx_hrxml_UserId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_UserId_GET_validFrom) */
struct zx_str* zx_hrxml_UserId_GET_validFrom(struct zx_hrxml_UserId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_UserId_PUT_validFrom) */
void zx_hrxml_UserId_PUT_validFrom(struct zx_hrxml_UserId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_UserId_GET_validTo) */
struct zx_str* zx_hrxml_UserId_GET_validTo(struct zx_hrxml_UserId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_UserId_PUT_validTo) */
void zx_hrxml_UserId_PUT_validTo(struct zx_hrxml_UserId_s* x, struct zx_str* y) { x->validTo = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidFrom_NUM_AnyDate) */

int zx_hrxml_ValidFrom_NUM_AnyDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidFrom_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_ValidFrom_GET_AnyDate(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_ValidFrom_POP_AnyDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_PUSH_AnyDate) */

void zx_hrxml_ValidFrom_PUSH_AnyDate(struct zx_hrxml_ValidFrom_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_ValidFrom_REV_AnyDate) */

void zx_hrxml_ValidFrom_REV_AnyDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidFrom_PUT_AnyDate) */

void zx_hrxml_ValidFrom_PUT_AnyDate(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidFrom_ADD_AnyDate) */

void zx_hrxml_ValidFrom_ADD_AnyDate(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidFrom_DEL_AnyDate) */

void zx_hrxml_ValidFrom_DEL_AnyDate(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidFrom_NUM_YearMonth) */

int zx_hrxml_ValidFrom_NUM_YearMonth(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidFrom_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_ValidFrom_GET_YearMonth(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_ValidFrom_POP_YearMonth(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_PUSH_YearMonth) */

void zx_hrxml_ValidFrom_PUSH_YearMonth(struct zx_hrxml_ValidFrom_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_ValidFrom_REV_YearMonth) */

void zx_hrxml_ValidFrom_REV_YearMonth(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidFrom_PUT_YearMonth) */

void zx_hrxml_ValidFrom_PUT_YearMonth(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidFrom_ADD_YearMonth) */

void zx_hrxml_ValidFrom_ADD_YearMonth(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidFrom_DEL_YearMonth) */

void zx_hrxml_ValidFrom_DEL_YearMonth(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidFrom_NUM_Year) */

int zx_hrxml_ValidFrom_NUM_Year(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidFrom_GET_Year) */

struct zx_elem_s* zx_hrxml_ValidFrom_GET_Year(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_POP_Year) */

struct zx_elem_s* zx_hrxml_ValidFrom_POP_Year(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_PUSH_Year) */

void zx_hrxml_ValidFrom_PUSH_Year(struct zx_hrxml_ValidFrom_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_ValidFrom_REV_Year) */

void zx_hrxml_ValidFrom_REV_Year(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidFrom_PUT_Year) */

void zx_hrxml_ValidFrom_PUT_Year(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidFrom_ADD_Year) */

void zx_hrxml_ValidFrom_ADD_Year(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidFrom_DEL_Year) */

void zx_hrxml_ValidFrom_DEL_Year(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidFrom_NUM_MonthDay) */

int zx_hrxml_ValidFrom_NUM_MonthDay(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidFrom_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_ValidFrom_GET_MonthDay(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_ValidFrom_POP_MonthDay(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_PUSH_MonthDay) */

void zx_hrxml_ValidFrom_PUSH_MonthDay(struct zx_hrxml_ValidFrom_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_ValidFrom_REV_MonthDay) */

void zx_hrxml_ValidFrom_REV_MonthDay(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidFrom_PUT_MonthDay) */

void zx_hrxml_ValidFrom_PUT_MonthDay(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidFrom_ADD_MonthDay) */

void zx_hrxml_ValidFrom_ADD_MonthDay(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidFrom_DEL_MonthDay) */

void zx_hrxml_ValidFrom_DEL_MonthDay(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidFrom_NUM_StringDate) */

int zx_hrxml_ValidFrom_NUM_StringDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidFrom_GET_StringDate) */

struct zx_elem_s* zx_hrxml_ValidFrom_GET_StringDate(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_POP_StringDate) */

struct zx_elem_s* zx_hrxml_ValidFrom_POP_StringDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidFrom_PUSH_StringDate) */

void zx_hrxml_ValidFrom_PUSH_StringDate(struct zx_hrxml_ValidFrom_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_ValidFrom_REV_StringDate) */

void zx_hrxml_ValidFrom_REV_StringDate(struct zx_hrxml_ValidFrom_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidFrom_PUT_StringDate) */

void zx_hrxml_ValidFrom_PUT_StringDate(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidFrom_ADD_StringDate) */

void zx_hrxml_ValidFrom_ADD_StringDate(struct zx_hrxml_ValidFrom_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidFrom_DEL_StringDate) */

void zx_hrxml_ValidFrom_DEL_StringDate(struct zx_hrxml_ValidFrom_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_ValidFrom_GET_dateDescription) */
struct zx_str* zx_hrxml_ValidFrom_GET_dateDescription(struct zx_hrxml_ValidFrom_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_ValidFrom_PUT_dateDescription) */
void zx_hrxml_ValidFrom_PUT_dateDescription(struct zx_hrxml_ValidFrom_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidTo_NUM_AnyDate) */

int zx_hrxml_ValidTo_NUM_AnyDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AnyDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidTo_GET_AnyDate) */

struct zx_elem_s* zx_hrxml_ValidTo_GET_AnyDate(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AnyDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_POP_AnyDate) */

struct zx_elem_s* zx_hrxml_ValidTo_POP_AnyDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AnyDate;
  if (y)
    x->AnyDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_PUSH_AnyDate) */

void zx_hrxml_ValidTo_PUSH_AnyDate(struct zx_hrxml_ValidTo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AnyDate->g;
  x->AnyDate = z;
}

/* FUNC(zx_hrxml_ValidTo_REV_AnyDate) */

void zx_hrxml_ValidTo_REV_AnyDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AnyDate;
  if (!y) return;
  x->AnyDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AnyDate->g;
    x->AnyDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidTo_PUT_AnyDate) */

void zx_hrxml_ValidTo_PUT_AnyDate(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AnyDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AnyDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidTo_ADD_AnyDate) */

void zx_hrxml_ValidTo_ADD_AnyDate(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AnyDate->g;
    x->AnyDate = z;
    return;
  case -1:
    y = x->AnyDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidTo_DEL_AnyDate) */

void zx_hrxml_ValidTo_DEL_AnyDate(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AnyDate = (struct zx_elem_s*)x->AnyDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AnyDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AnyDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidTo_NUM_YearMonth) */

int zx_hrxml_ValidTo_NUM_YearMonth(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->YearMonth; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidTo_GET_YearMonth) */

struct zx_elem_s* zx_hrxml_ValidTo_GET_YearMonth(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->YearMonth; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_POP_YearMonth) */

struct zx_elem_s* zx_hrxml_ValidTo_POP_YearMonth(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->YearMonth;
  if (y)
    x->YearMonth = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_PUSH_YearMonth) */

void zx_hrxml_ValidTo_PUSH_YearMonth(struct zx_hrxml_ValidTo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->YearMonth->g;
  x->YearMonth = z;
}

/* FUNC(zx_hrxml_ValidTo_REV_YearMonth) */

void zx_hrxml_ValidTo_REV_YearMonth(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->YearMonth;
  if (!y) return;
  x->YearMonth = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->YearMonth->g;
    x->YearMonth = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidTo_PUT_YearMonth) */

void zx_hrxml_ValidTo_PUT_YearMonth(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->YearMonth;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->YearMonth = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidTo_ADD_YearMonth) */

void zx_hrxml_ValidTo_ADD_YearMonth(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->YearMonth->g;
    x->YearMonth = z;
    return;
  case -1:
    y = x->YearMonth;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidTo_DEL_YearMonth) */

void zx_hrxml_ValidTo_DEL_YearMonth(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->YearMonth = (struct zx_elem_s*)x->YearMonth->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->YearMonth;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->YearMonth; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidTo_NUM_Year) */

int zx_hrxml_ValidTo_NUM_Year(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Year; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidTo_GET_Year) */

struct zx_elem_s* zx_hrxml_ValidTo_GET_Year(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->Year; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_POP_Year) */

struct zx_elem_s* zx_hrxml_ValidTo_POP_Year(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->Year;
  if (y)
    x->Year = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_PUSH_Year) */

void zx_hrxml_ValidTo_PUSH_Year(struct zx_hrxml_ValidTo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->Year->g;
  x->Year = z;
}

/* FUNC(zx_hrxml_ValidTo_REV_Year) */

void zx_hrxml_ValidTo_REV_Year(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->Year;
  if (!y) return;
  x->Year = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->Year->g;
    x->Year = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidTo_PUT_Year) */

void zx_hrxml_ValidTo_PUT_Year(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->Year;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->Year = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidTo_ADD_Year) */

void zx_hrxml_ValidTo_ADD_Year(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->Year->g;
    x->Year = z;
    return;
  case -1:
    y = x->Year;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidTo_DEL_Year) */

void zx_hrxml_ValidTo_DEL_Year(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Year = (struct zx_elem_s*)x->Year->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->Year;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->Year; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidTo_NUM_MonthDay) */

int zx_hrxml_ValidTo_NUM_MonthDay(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->MonthDay; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidTo_GET_MonthDay) */

struct zx_elem_s* zx_hrxml_ValidTo_GET_MonthDay(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->MonthDay; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_POP_MonthDay) */

struct zx_elem_s* zx_hrxml_ValidTo_POP_MonthDay(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->MonthDay;
  if (y)
    x->MonthDay = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_PUSH_MonthDay) */

void zx_hrxml_ValidTo_PUSH_MonthDay(struct zx_hrxml_ValidTo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->MonthDay->g;
  x->MonthDay = z;
}

/* FUNC(zx_hrxml_ValidTo_REV_MonthDay) */

void zx_hrxml_ValidTo_REV_MonthDay(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->MonthDay;
  if (!y) return;
  x->MonthDay = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->MonthDay->g;
    x->MonthDay = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidTo_PUT_MonthDay) */

void zx_hrxml_ValidTo_PUT_MonthDay(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->MonthDay;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->MonthDay = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidTo_ADD_MonthDay) */

void zx_hrxml_ValidTo_ADD_MonthDay(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->MonthDay->g;
    x->MonthDay = z;
    return;
  case -1:
    y = x->MonthDay;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidTo_DEL_MonthDay) */

void zx_hrxml_ValidTo_DEL_MonthDay(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->MonthDay = (struct zx_elem_s*)x->MonthDay->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->MonthDay;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->MonthDay; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_ValidTo_NUM_StringDate) */

int zx_hrxml_ValidTo_NUM_StringDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->StringDate; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_ValidTo_GET_StringDate) */

struct zx_elem_s* zx_hrxml_ValidTo_GET_StringDate(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->StringDate; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_POP_StringDate) */

struct zx_elem_s* zx_hrxml_ValidTo_POP_StringDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->StringDate;
  if (y)
    x->StringDate = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_ValidTo_PUSH_StringDate) */

void zx_hrxml_ValidTo_PUSH_StringDate(struct zx_hrxml_ValidTo_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->StringDate->g;
  x->StringDate = z;
}

/* FUNC(zx_hrxml_ValidTo_REV_StringDate) */

void zx_hrxml_ValidTo_REV_StringDate(struct zx_hrxml_ValidTo_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->StringDate;
  if (!y) return;
  x->StringDate = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->StringDate->g;
    x->StringDate = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_ValidTo_PUT_StringDate) */

void zx_hrxml_ValidTo_PUT_StringDate(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->StringDate;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->StringDate = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_ValidTo_ADD_StringDate) */

void zx_hrxml_ValidTo_ADD_StringDate(struct zx_hrxml_ValidTo_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->StringDate->g;
    x->StringDate = z;
    return;
  case -1:
    y = x->StringDate;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_ValidTo_DEL_StringDate) */

void zx_hrxml_ValidTo_DEL_StringDate(struct zx_hrxml_ValidTo_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->StringDate = (struct zx_elem_s*)x->StringDate->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->StringDate;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->StringDate; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif

/* FUNC(zx_hrxml_ValidTo_GET_dateDescription) */
struct zx_str* zx_hrxml_ValidTo_GET_dateDescription(struct zx_hrxml_ValidTo_s* x) { return x->dateDescription; }
/* FUNC(zx_hrxml_ValidTo_PUT_dateDescription) */
void zx_hrxml_ValidTo_PUT_dateDescription(struct zx_hrxml_ValidTo_s* x, struct zx_str* y) { x->dateDescription = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_ContactInfo) */

int zx_hrxml_Verification_NUM_ContactInfo(struct zx_hrxml_Verification_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ContactInfo; y; ++n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_Verification_GET_ContactInfo(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  for (y = x->ContactInfo; n>=0 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_ContactInfo) */

struct zx_hrxml_ContactInfo_s* zx_hrxml_Verification_POP_ContactInfo(struct zx_hrxml_Verification_s* x)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return 0;
  y = x->ContactInfo;
  if (y)
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_ContactInfo) */

void zx_hrxml_Verification_PUSH_ContactInfo(struct zx_hrxml_Verification_s* x, struct zx_hrxml_ContactInfo_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ContactInfo->gg.g;
  x->ContactInfo = z;
}

/* FUNC(zx_hrxml_Verification_REV_ContactInfo) */

void zx_hrxml_Verification_REV_ContactInfo(struct zx_hrxml_Verification_s* x)
{
  struct zx_hrxml_ContactInfo_s* nxt;
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  y = x->ContactInfo;
  if (!y) return;
  x->ContactInfo = 0;
  while (y) {
    nxt = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n;
    y->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_ContactInfo) */

void zx_hrxml_Verification_PUT_ContactInfo(struct zx_hrxml_Verification_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  y = x->ContactInfo;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ContactInfo = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_ContactInfo) */

void zx_hrxml_Verification_ADD_ContactInfo(struct zx_hrxml_Verification_s* x, int n, struct zx_hrxml_ContactInfo_s* z)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ContactInfo->gg.g;
    x->ContactInfo = z;
    return;
  case -1:
    y = x->ContactInfo;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_Verification_DEL_ContactInfo) */

void zx_hrxml_Verification_DEL_ContactInfo(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_hrxml_ContactInfo_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ContactInfo = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ContactInfo_s*)x->ContactInfo;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ContactInfo; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ContactInfo_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_ReasonForLeaving) */

int zx_hrxml_Verification_NUM_ReasonForLeaving(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ReasonForLeaving; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_ReasonForLeaving) */

struct zx_elem_s* zx_hrxml_Verification_GET_ReasonForLeaving(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->ReasonForLeaving; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_ReasonForLeaving) */

struct zx_elem_s* zx_hrxml_Verification_POP_ReasonForLeaving(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->ReasonForLeaving;
  if (y)
    x->ReasonForLeaving = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_ReasonForLeaving) */

void zx_hrxml_Verification_PUSH_ReasonForLeaving(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->ReasonForLeaving->g;
  x->ReasonForLeaving = z;
}

/* FUNC(zx_hrxml_Verification_REV_ReasonForLeaving) */

void zx_hrxml_Verification_REV_ReasonForLeaving(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->ReasonForLeaving;
  if (!y) return;
  x->ReasonForLeaving = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->ReasonForLeaving->g;
    x->ReasonForLeaving = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_ReasonForLeaving) */

void zx_hrxml_Verification_PUT_ReasonForLeaving(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->ReasonForLeaving;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->ReasonForLeaving = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_ReasonForLeaving) */

void zx_hrxml_Verification_ADD_ReasonForLeaving(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->ReasonForLeaving->g;
    x->ReasonForLeaving = z;
    return;
  case -1:
    y = x->ReasonForLeaving;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ReasonForLeaving; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_ReasonForLeaving) */

void zx_hrxml_Verification_DEL_ReasonForLeaving(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ReasonForLeaving = (struct zx_elem_s*)x->ReasonForLeaving->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->ReasonForLeaving;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->ReasonForLeaving; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_PermissionToContact) */

int zx_hrxml_Verification_NUM_PermissionToContact(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PermissionToContact; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_PermissionToContact) */

struct zx_elem_s* zx_hrxml_Verification_GET_PermissionToContact(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->PermissionToContact; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_PermissionToContact) */

struct zx_elem_s* zx_hrxml_Verification_POP_PermissionToContact(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->PermissionToContact;
  if (y)
    x->PermissionToContact = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_PermissionToContact) */

void zx_hrxml_Verification_PUSH_PermissionToContact(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->PermissionToContact->g;
  x->PermissionToContact = z;
}

/* FUNC(zx_hrxml_Verification_REV_PermissionToContact) */

void zx_hrxml_Verification_REV_PermissionToContact(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->PermissionToContact;
  if (!y) return;
  x->PermissionToContact = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->PermissionToContact->g;
    x->PermissionToContact = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_PermissionToContact) */

void zx_hrxml_Verification_PUT_PermissionToContact(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->PermissionToContact;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->PermissionToContact = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_PermissionToContact) */

void zx_hrxml_Verification_ADD_PermissionToContact(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->PermissionToContact->g;
    x->PermissionToContact = z;
    return;
  case -1:
    y = x->PermissionToContact;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PermissionToContact; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_PermissionToContact) */

void zx_hrxml_Verification_DEL_PermissionToContact(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PermissionToContact = (struct zx_elem_s*)x->PermissionToContact->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->PermissionToContact;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->PermissionToContact; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_VerifyEmployment) */

int zx_hrxml_Verification_NUM_VerifyEmployment(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->VerifyEmployment; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_VerifyEmployment) */

struct zx_elem_s* zx_hrxml_Verification_GET_VerifyEmployment(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->VerifyEmployment; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_VerifyEmployment) */

struct zx_elem_s* zx_hrxml_Verification_POP_VerifyEmployment(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->VerifyEmployment;
  if (y)
    x->VerifyEmployment = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_VerifyEmployment) */

void zx_hrxml_Verification_PUSH_VerifyEmployment(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->VerifyEmployment->g;
  x->VerifyEmployment = z;
}

/* FUNC(zx_hrxml_Verification_REV_VerifyEmployment) */

void zx_hrxml_Verification_REV_VerifyEmployment(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->VerifyEmployment;
  if (!y) return;
  x->VerifyEmployment = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->VerifyEmployment->g;
    x->VerifyEmployment = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_VerifyEmployment) */

void zx_hrxml_Verification_PUT_VerifyEmployment(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->VerifyEmployment;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->VerifyEmployment = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_VerifyEmployment) */

void zx_hrxml_Verification_ADD_VerifyEmployment(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->VerifyEmployment->g;
    x->VerifyEmployment = z;
    return;
  case -1:
    y = x->VerifyEmployment;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->VerifyEmployment; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_VerifyEmployment) */

void zx_hrxml_Verification_DEL_VerifyEmployment(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->VerifyEmployment = (struct zx_elem_s*)x->VerifyEmployment->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->VerifyEmployment;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->VerifyEmployment; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_EligibleForRehire) */

int zx_hrxml_Verification_NUM_EligibleForRehire(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EligibleForRehire; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_EligibleForRehire) */

struct zx_elem_s* zx_hrxml_Verification_GET_EligibleForRehire(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EligibleForRehire; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_EligibleForRehire) */

struct zx_elem_s* zx_hrxml_Verification_POP_EligibleForRehire(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EligibleForRehire;
  if (y)
    x->EligibleForRehire = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_EligibleForRehire) */

void zx_hrxml_Verification_PUSH_EligibleForRehire(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EligibleForRehire->g;
  x->EligibleForRehire = z;
}

/* FUNC(zx_hrxml_Verification_REV_EligibleForRehire) */

void zx_hrxml_Verification_REV_EligibleForRehire(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EligibleForRehire;
  if (!y) return;
  x->EligibleForRehire = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EligibleForRehire->g;
    x->EligibleForRehire = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_EligibleForRehire) */

void zx_hrxml_Verification_PUT_EligibleForRehire(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EligibleForRehire;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EligibleForRehire = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_EligibleForRehire) */

void zx_hrxml_Verification_ADD_EligibleForRehire(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EligibleForRehire->g;
    x->EligibleForRehire = z;
    return;
  case -1:
    y = x->EligibleForRehire;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EligibleForRehire; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_EligibleForRehire) */

void zx_hrxml_Verification_DEL_EligibleForRehire(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EligibleForRehire = (struct zx_elem_s*)x->EligibleForRehire->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EligibleForRehire;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EligibleForRehire; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_AttendanceRating) */

int zx_hrxml_Verification_NUM_AttendanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->AttendanceRating; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_AttendanceRating) */

struct zx_elem_s* zx_hrxml_Verification_GET_AttendanceRating(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->AttendanceRating; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_AttendanceRating) */

struct zx_elem_s* zx_hrxml_Verification_POP_AttendanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->AttendanceRating;
  if (y)
    x->AttendanceRating = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_AttendanceRating) */

void zx_hrxml_Verification_PUSH_AttendanceRating(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->AttendanceRating->g;
  x->AttendanceRating = z;
}

/* FUNC(zx_hrxml_Verification_REV_AttendanceRating) */

void zx_hrxml_Verification_REV_AttendanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->AttendanceRating;
  if (!y) return;
  x->AttendanceRating = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->AttendanceRating->g;
    x->AttendanceRating = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_AttendanceRating) */

void zx_hrxml_Verification_PUT_AttendanceRating(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->AttendanceRating;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->AttendanceRating = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_AttendanceRating) */

void zx_hrxml_Verification_ADD_AttendanceRating(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->AttendanceRating->g;
    x->AttendanceRating = z;
    return;
  case -1:
    y = x->AttendanceRating;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AttendanceRating; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_AttendanceRating) */

void zx_hrxml_Verification_DEL_AttendanceRating(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->AttendanceRating = (struct zx_elem_s*)x->AttendanceRating->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->AttendanceRating;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->AttendanceRating; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_OverallPerformanceRating) */

int zx_hrxml_Verification_NUM_OverallPerformanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->OverallPerformanceRating; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_OverallPerformanceRating) */

struct zx_elem_s* zx_hrxml_Verification_GET_OverallPerformanceRating(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->OverallPerformanceRating; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_OverallPerformanceRating) */

struct zx_elem_s* zx_hrxml_Verification_POP_OverallPerformanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->OverallPerformanceRating;
  if (y)
    x->OverallPerformanceRating = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_OverallPerformanceRating) */

void zx_hrxml_Verification_PUSH_OverallPerformanceRating(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->OverallPerformanceRating->g;
  x->OverallPerformanceRating = z;
}

/* FUNC(zx_hrxml_Verification_REV_OverallPerformanceRating) */

void zx_hrxml_Verification_REV_OverallPerformanceRating(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->OverallPerformanceRating;
  if (!y) return;
  x->OverallPerformanceRating = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->OverallPerformanceRating->g;
    x->OverallPerformanceRating = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_OverallPerformanceRating) */

void zx_hrxml_Verification_PUT_OverallPerformanceRating(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->OverallPerformanceRating;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->OverallPerformanceRating = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_OverallPerformanceRating) */

void zx_hrxml_Verification_ADD_OverallPerformanceRating(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->OverallPerformanceRating->g;
    x->OverallPerformanceRating = z;
    return;
  case -1:
    y = x->OverallPerformanceRating;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OverallPerformanceRating; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_OverallPerformanceRating) */

void zx_hrxml_Verification_DEL_OverallPerformanceRating(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->OverallPerformanceRating = (struct zx_elem_s*)x->OverallPerformanceRating->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->OverallPerformanceRating;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->OverallPerformanceRating; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_Verification_NUM_QuestionAnswerPair) */

int zx_hrxml_Verification_NUM_QuestionAnswerPair(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->QuestionAnswerPair; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_Verification_GET_QuestionAnswerPair) */

struct zx_elem_s* zx_hrxml_Verification_GET_QuestionAnswerPair(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->QuestionAnswerPair; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_Verification_POP_QuestionAnswerPair) */

struct zx_elem_s* zx_hrxml_Verification_POP_QuestionAnswerPair(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->QuestionAnswerPair;
  if (y)
    x->QuestionAnswerPair = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_Verification_PUSH_QuestionAnswerPair) */

void zx_hrxml_Verification_PUSH_QuestionAnswerPair(struct zx_hrxml_Verification_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->QuestionAnswerPair->g;
  x->QuestionAnswerPair = z;
}

/* FUNC(zx_hrxml_Verification_REV_QuestionAnswerPair) */

void zx_hrxml_Verification_REV_QuestionAnswerPair(struct zx_hrxml_Verification_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->QuestionAnswerPair;
  if (!y) return;
  x->QuestionAnswerPair = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->QuestionAnswerPair->g;
    x->QuestionAnswerPair = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_Verification_PUT_QuestionAnswerPair) */

void zx_hrxml_Verification_PUT_QuestionAnswerPair(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->QuestionAnswerPair;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->QuestionAnswerPair = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_Verification_ADD_QuestionAnswerPair) */

void zx_hrxml_Verification_ADD_QuestionAnswerPair(struct zx_hrxml_Verification_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->QuestionAnswerPair->g;
    x->QuestionAnswerPair = z;
    return;
  case -1:
    y = x->QuestionAnswerPair;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->QuestionAnswerPair; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_Verification_DEL_QuestionAnswerPair) */

void zx_hrxml_Verification_DEL_QuestionAnswerPair(struct zx_hrxml_Verification_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->QuestionAnswerPair = (struct zx_elem_s*)x->QuestionAnswerPair->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->QuestionAnswerPair;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->QuestionAnswerPair; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif











/* FUNC(zx_hrxml_VisaStatus_GET_countryCode) */
struct zx_str* zx_hrxml_VisaStatus_GET_countryCode(struct zx_hrxml_VisaStatus_s* x) { return x->countryCode; }
/* FUNC(zx_hrxml_VisaStatus_PUT_countryCode) */
void zx_hrxml_VisaStatus_PUT_countryCode(struct zx_hrxml_VisaStatus_s* x, struct zx_str* y) { x->countryCode = y; }
/* FUNC(zx_hrxml_VisaStatus_GET_validFrom) */
struct zx_str* zx_hrxml_VisaStatus_GET_validFrom(struct zx_hrxml_VisaStatus_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_VisaStatus_PUT_validFrom) */
void zx_hrxml_VisaStatus_PUT_validFrom(struct zx_hrxml_VisaStatus_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_VisaStatus_GET_validTo) */
struct zx_str* zx_hrxml_VisaStatus_GET_validTo(struct zx_hrxml_VisaStatus_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_VisaStatus_PUT_validTo) */
void zx_hrxml_VisaStatus_PUT_validTo(struct zx_hrxml_VisaStatus_s* x, struct zx_str* y) { x->validTo = y; }





/* FUNC(zx_hrxml_Weight_GET_description) */
struct zx_str* zx_hrxml_Weight_GET_description(struct zx_hrxml_Weight_s* x) { return x->description; }
/* FUNC(zx_hrxml_Weight_PUT_description) */
void zx_hrxml_Weight_PUT_description(struct zx_hrxml_Weight_s* x, struct zx_str* y) { x->description = y; }
/* FUNC(zx_hrxml_Weight_GET_interval) */
struct zx_str* zx_hrxml_Weight_GET_interval(struct zx_hrxml_Weight_s* x) { return x->interval; }
/* FUNC(zx_hrxml_Weight_PUT_interval) */
void zx_hrxml_Weight_PUT_interval(struct zx_hrxml_Weight_s* x, struct zx_str* y) { x->interval = y; }
/* FUNC(zx_hrxml_Weight_GET_maxValue) */
struct zx_str* zx_hrxml_Weight_GET_maxValue(struct zx_hrxml_Weight_s* x) { return x->maxValue; }
/* FUNC(zx_hrxml_Weight_PUT_maxValue) */
void zx_hrxml_Weight_PUT_maxValue(struct zx_hrxml_Weight_s* x, struct zx_str* y) { x->maxValue = y; }
/* FUNC(zx_hrxml_Weight_GET_minValue) */
struct zx_str* zx_hrxml_Weight_GET_minValue(struct zx_hrxml_Weight_s* x) { return x->minValue; }
/* FUNC(zx_hrxml_Weight_PUT_minValue) */
void zx_hrxml_Weight_PUT_minValue(struct zx_hrxml_Weight_s* x, struct zx_str* y) { x->minValue = y; }







#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_WorkSiteName) */

int zx_hrxml_WorkSite_NUM_WorkSiteName(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSiteName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_WorkSiteName) */

struct zx_elem_s* zx_hrxml_WorkSite_GET_WorkSiteName(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->WorkSiteName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_WorkSiteName) */

struct zx_elem_s* zx_hrxml_WorkSite_POP_WorkSiteName(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->WorkSiteName;
  if (y)
    x->WorkSiteName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_WorkSiteName) */

void zx_hrxml_WorkSite_PUSH_WorkSiteName(struct zx_hrxml_WorkSite_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->WorkSiteName->g;
  x->WorkSiteName = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_WorkSiteName) */

void zx_hrxml_WorkSite_REV_WorkSiteName(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->WorkSiteName;
  if (!y) return;
  x->WorkSiteName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->WorkSiteName->g;
    x->WorkSiteName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_WorkSiteName) */

void zx_hrxml_WorkSite_PUT_WorkSiteName(struct zx_hrxml_WorkSite_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->WorkSiteName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->WorkSiteName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_WorkSiteName) */

void zx_hrxml_WorkSite_ADD_WorkSiteName(struct zx_hrxml_WorkSite_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->WorkSiteName->g;
    x->WorkSiteName = z;
    return;
  case -1:
    y = x->WorkSiteName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkSiteName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_WorkSiteName) */

void zx_hrxml_WorkSite_DEL_WorkSiteName(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSiteName = (struct zx_elem_s*)x->WorkSiteName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->WorkSiteName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->WorkSiteName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_WorkSiteId) */

int zx_hrxml_WorkSite_NUM_WorkSiteId(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSiteId; y; ++n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_WorkSiteId) */

struct zx_hrxml_WorkSiteId_s* zx_hrxml_WorkSite_GET_WorkSiteId(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return 0;
  for (y = x->WorkSiteId; n>=0 && y; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_WorkSiteId) */

struct zx_hrxml_WorkSiteId_s* zx_hrxml_WorkSite_POP_WorkSiteId(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return 0;
  y = x->WorkSiteId;
  if (y)
    x->WorkSiteId = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_WorkSiteId) */

void zx_hrxml_WorkSite_PUSH_WorkSiteId(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_WorkSiteId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSiteId->gg.g;
  x->WorkSiteId = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_WorkSiteId) */

void zx_hrxml_WorkSite_REV_WorkSiteId(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteId_s* nxt;
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return;
  y = x->WorkSiteId;
  if (!y) return;
  x->WorkSiteId = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSiteId->gg.g;
    x->WorkSiteId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_WorkSiteId) */

void zx_hrxml_WorkSite_PUT_WorkSiteId(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_WorkSiteId_s* z)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x || !z) return;
  y = x->WorkSiteId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSiteId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_WorkSiteId) */

void zx_hrxml_WorkSite_ADD_WorkSiteId(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_WorkSiteId_s* z)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSiteId->gg.g;
    x->WorkSiteId = z;
    return;
  case -1:
    y = x->WorkSiteId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteId; n > 1 && y; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_WorkSiteId) */

void zx_hrxml_WorkSite_DEL_WorkSiteId(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSiteId = (struct zx_hrxml_WorkSiteId_s*)x->WorkSiteId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSiteId_s*)x->WorkSiteId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_Details) */

int zx_hrxml_WorkSite_NUM_Details(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_Details_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Details; y; ++n, y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_Details) */

struct zx_hrxml_Details_s* zx_hrxml_WorkSite_GET_Details(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_Details_s* y;
  if (!x) return 0;
  for (y = x->Details; n>=0 && y; --n, y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_Details) */

struct zx_hrxml_Details_s* zx_hrxml_WorkSite_POP_Details(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_Details_s* y;
  if (!x) return 0;
  y = x->Details;
  if (y)
    x->Details = (struct zx_hrxml_Details_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_Details) */

void zx_hrxml_WorkSite_PUSH_Details(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_Details_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Details->gg.g;
  x->Details = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_Details) */

void zx_hrxml_WorkSite_REV_Details(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_Details_s* nxt;
  struct zx_hrxml_Details_s* y;
  if (!x) return;
  y = x->Details;
  if (!y) return;
  x->Details = 0;
  while (y) {
    nxt = (struct zx_hrxml_Details_s*)y->gg.g.n;
    y->gg.g.n = &x->Details->gg.g;
    x->Details = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_Details) */

void zx_hrxml_WorkSite_PUT_Details(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_Details_s* z)
{
  struct zx_hrxml_Details_s* y;
  if (!x || !z) return;
  y = x->Details;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Details = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_Details) */

void zx_hrxml_WorkSite_ADD_Details(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_Details_s* z)
{
  struct zx_hrxml_Details_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Details->gg.g;
    x->Details = z;
    return;
  case -1:
    y = x->Details;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Details; n > 1 && y; --n, y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_Details) */

void zx_hrxml_WorkSite_DEL_Details(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_Details_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Details = (struct zx_hrxml_Details_s*)x->Details->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Details_s*)x->Details;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Details; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Details_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_PostalAddress) */

int zx_hrxml_WorkSite_NUM_PostalAddress(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->PostalAddress; y; ++n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_WorkSite_GET_PostalAddress(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  for (y = x->PostalAddress; n>=0 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_PostalAddress) */

struct zx_hrxml_PostalAddress_s* zx_hrxml_WorkSite_POP_PostalAddress(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return 0;
  y = x->PostalAddress;
  if (y)
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_PostalAddress) */

void zx_hrxml_WorkSite_PUSH_PostalAddress(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_PostalAddress_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->PostalAddress->gg.g;
  x->PostalAddress = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_PostalAddress) */

void zx_hrxml_WorkSite_REV_PostalAddress(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_PostalAddress_s* nxt;
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  y = x->PostalAddress;
  if (!y) return;
  x->PostalAddress = 0;
  while (y) {
    nxt = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n;
    y->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_PostalAddress) */

void zx_hrxml_WorkSite_PUT_PostalAddress(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  y = x->PostalAddress;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->PostalAddress = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_PostalAddress) */

void zx_hrxml_WorkSite_ADD_PostalAddress(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_PostalAddress_s* z)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->PostalAddress->gg.g;
    x->PostalAddress = z;
    return;
  case -1:
    y = x->PostalAddress;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_PostalAddress) */

void zx_hrxml_WorkSite_DEL_PostalAddress(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_PostalAddress_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->PostalAddress = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_PostalAddress_s*)x->PostalAddress;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->PostalAddress; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_PostalAddress_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_TravelDirections) */

int zx_hrxml_WorkSite_NUM_TravelDirections(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->TravelDirections; y; ++n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_WorkSite_GET_TravelDirections(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  for (y = x->TravelDirections; n>=0 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_TravelDirections) */

struct zx_hrxml_TravelDirections_s* zx_hrxml_WorkSite_POP_TravelDirections(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return 0;
  y = x->TravelDirections;
  if (y)
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_TravelDirections) */

void zx_hrxml_WorkSite_PUSH_TravelDirections(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_TravelDirections_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->TravelDirections->gg.g;
  x->TravelDirections = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_TravelDirections) */

void zx_hrxml_WorkSite_REV_TravelDirections(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_TravelDirections_s* nxt;
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  y = x->TravelDirections;
  if (!y) return;
  x->TravelDirections = 0;
  while (y) {
    nxt = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n;
    y->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_TravelDirections) */

void zx_hrxml_WorkSite_PUT_TravelDirections(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  y = x->TravelDirections;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->TravelDirections = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_TravelDirections) */

void zx_hrxml_WorkSite_ADD_TravelDirections(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_TravelDirections_s* z)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->TravelDirections->gg.g;
    x->TravelDirections = z;
    return;
  case -1:
    y = x->TravelDirections;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_TravelDirections) */

void zx_hrxml_WorkSite_DEL_TravelDirections(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_TravelDirections_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->TravelDirections = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_TravelDirections_s*)x->TravelDirections;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->TravelDirections; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_TravelDirections_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_ParkingInstructions) */

int zx_hrxml_WorkSite_NUM_ParkingInstructions(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->ParkingInstructions; y; ++n, y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_ParkingInstructions) */

struct zx_hrxml_ParkingInstructions_s* zx_hrxml_WorkSite_GET_ParkingInstructions(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x) return 0;
  for (y = x->ParkingInstructions; n>=0 && y; --n, y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_ParkingInstructions) */

struct zx_hrxml_ParkingInstructions_s* zx_hrxml_WorkSite_POP_ParkingInstructions(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x) return 0;
  y = x->ParkingInstructions;
  if (y)
    x->ParkingInstructions = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_ParkingInstructions) */

void zx_hrxml_WorkSite_PUSH_ParkingInstructions(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_ParkingInstructions_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->ParkingInstructions->gg.g;
  x->ParkingInstructions = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_ParkingInstructions) */

void zx_hrxml_WorkSite_REV_ParkingInstructions(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_ParkingInstructions_s* nxt;
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x) return;
  y = x->ParkingInstructions;
  if (!y) return;
  x->ParkingInstructions = 0;
  while (y) {
    nxt = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n;
    y->gg.g.n = &x->ParkingInstructions->gg.g;
    x->ParkingInstructions = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_ParkingInstructions) */

void zx_hrxml_WorkSite_PUT_ParkingInstructions(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_ParkingInstructions_s* z)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x || !z) return;
  y = x->ParkingInstructions;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->ParkingInstructions = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_ParkingInstructions) */

void zx_hrxml_WorkSite_ADD_ParkingInstructions(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_ParkingInstructions_s* z)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->ParkingInstructions->gg.g;
    x->ParkingInstructions = z;
    return;
  case -1:
    y = x->ParkingInstructions;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ParkingInstructions; n > 1 && y; --n, y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_ParkingInstructions) */

void zx_hrxml_WorkSite_DEL_ParkingInstructions(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_ParkingInstructions_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->ParkingInstructions = (struct zx_hrxml_ParkingInstructions_s*)x->ParkingInstructions->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_ParkingInstructions_s*)x->ParkingInstructions;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->ParkingInstructions; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_ParkingInstructions_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_WorkSiteEnvironment) */

int zx_hrxml_WorkSite_NUM_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSiteEnvironment; y; ++n, y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_WorkSiteEnvironment) */

struct zx_hrxml_WorkSiteEnvironment_s* zx_hrxml_WorkSite_GET_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x) return 0;
  for (y = x->WorkSiteEnvironment; n>=0 && y; --n, y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_WorkSiteEnvironment) */

struct zx_hrxml_WorkSiteEnvironment_s* zx_hrxml_WorkSite_POP_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x) return 0;
  y = x->WorkSiteEnvironment;
  if (y)
    x->WorkSiteEnvironment = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_WorkSiteEnvironment) */

void zx_hrxml_WorkSite_PUSH_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_WorkSiteEnvironment_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSiteEnvironment->gg.g;
  x->WorkSiteEnvironment = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_WorkSiteEnvironment) */

void zx_hrxml_WorkSite_REV_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_WorkSiteEnvironment_s* nxt;
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x) return;
  y = x->WorkSiteEnvironment;
  if (!y) return;
  x->WorkSiteEnvironment = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSiteEnvironment->gg.g;
    x->WorkSiteEnvironment = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_WorkSiteEnvironment) */

void zx_hrxml_WorkSite_PUT_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_WorkSiteEnvironment_s* z)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x || !z) return;
  y = x->WorkSiteEnvironment;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSiteEnvironment = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_WorkSiteEnvironment) */

void zx_hrxml_WorkSite_ADD_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_WorkSiteEnvironment_s* z)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSiteEnvironment->gg.g;
    x->WorkSiteEnvironment = z;
    return;
  case -1:
    y = x->WorkSiteEnvironment;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteEnvironment; n > 1 && y; --n, y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_WorkSiteEnvironment) */

void zx_hrxml_WorkSite_DEL_WorkSiteEnvironment(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_WorkSiteEnvironment_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSiteEnvironment = (struct zx_hrxml_WorkSiteEnvironment_s*)x->WorkSiteEnvironment->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSiteEnvironment_s*)x->WorkSiteEnvironment;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteEnvironment; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteEnvironment_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSite_NUM_UserArea) */

int zx_hrxml_WorkSite_NUM_UserArea(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSite_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_WorkSite_GET_UserArea(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_WorkSite_POP_UserArea(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSite_PUSH_UserArea) */

void zx_hrxml_WorkSite_PUSH_UserArea(struct zx_hrxml_WorkSite_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_WorkSite_REV_UserArea) */

void zx_hrxml_WorkSite_REV_UserArea(struct zx_hrxml_WorkSite_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSite_PUT_UserArea) */

void zx_hrxml_WorkSite_PUT_UserArea(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSite_ADD_UserArea) */

void zx_hrxml_WorkSite_ADD_UserArea(struct zx_hrxml_WorkSite_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSite_DEL_UserArea) */

void zx_hrxml_WorkSite_DEL_UserArea(struct zx_hrxml_WorkSite_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_EnvironmentName) */

int zx_hrxml_WorkSiteEnvironment_NUM_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_elem_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EnvironmentName; y; ++n, y = (struct zx_elem_s*)y->g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_EnvironmentName) */

struct zx_elem_s* zx_hrxml_WorkSiteEnvironment_GET_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  for (y = x->EnvironmentName; n>=0 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_EnvironmentName) */

struct zx_elem_s* zx_hrxml_WorkSiteEnvironment_POP_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_elem_s* y;
  if (!x) return 0;
  y = x->EnvironmentName;
  if (y)
    x->EnvironmentName = (struct zx_elem_s*)y->g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_EnvironmentName) */

void zx_hrxml_WorkSiteEnvironment_PUSH_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_elem_s* z)
{
  if (!x || !z) return;
  z->g.n = &x->EnvironmentName->g;
  x->EnvironmentName = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_EnvironmentName) */

void zx_hrxml_WorkSiteEnvironment_REV_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_elem_s* nxt;
  struct zx_elem_s* y;
  if (!x) return;
  y = x->EnvironmentName;
  if (!y) return;
  x->EnvironmentName = 0;
  while (y) {
    nxt = (struct zx_elem_s*)y->g.n;
    y->g.n = &x->EnvironmentName->g;
    x->EnvironmentName = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_EnvironmentName) */

void zx_hrxml_WorkSiteEnvironment_PUT_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  y = x->EnvironmentName;
  if (!y) return;
  switch (n) {
  case 0:
    z->g.n = y->g.n;
    x->EnvironmentName = z;
    return;
  default:
    for (; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
    z->g.n = y->g.n->n;
    y->g.n = &z->g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_EnvironmentName) */

void zx_hrxml_WorkSiteEnvironment_ADD_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_elem_s* z)
{
  struct zx_elem_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->g.n = &x->EnvironmentName->g;
    x->EnvironmentName = z;
    return;
  case -1:
    y = x->EnvironmentName;
    if (!y) goto add_to_start;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EnvironmentName; n > 1 && y; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y) return;
  }
  z->g.n = y->g.n;
  y->g.n = &z->g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_EnvironmentName) */

void zx_hrxml_WorkSiteEnvironment_DEL_EnvironmentName(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_elem_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EnvironmentName = (struct zx_elem_s*)x->EnvironmentName->g.n;
    return;
  case -1:
    y = (struct zx_elem_s*)x->EnvironmentName;
    if (!y) return;
    for (; y->g.n; y = (struct zx_elem_s*)y->g.n) ;
    break;
  default:
    for (y = x->EnvironmentName; n > 1 && y->g.n; --n, y = (struct zx_elem_s*)y->g.n) ;
    if (!y->g.n) return;
  }
  y->g.n = y->g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_EnvironmentId) */

int zx_hrxml_WorkSiteEnvironment_NUM_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_EnvironmentId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->EnvironmentId; y; ++n, y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_EnvironmentId) */

struct zx_hrxml_EnvironmentId_s* zx_hrxml_WorkSiteEnvironment_GET_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x) return 0;
  for (y = x->EnvironmentId; n>=0 && y; --n, y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_EnvironmentId) */

struct zx_hrxml_EnvironmentId_s* zx_hrxml_WorkSiteEnvironment_POP_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x) return 0;
  y = x->EnvironmentId;
  if (y)
    x->EnvironmentId = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_EnvironmentId) */

void zx_hrxml_WorkSiteEnvironment_PUSH_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_hrxml_EnvironmentId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->EnvironmentId->gg.g;
  x->EnvironmentId = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_EnvironmentId) */

void zx_hrxml_WorkSiteEnvironment_REV_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_EnvironmentId_s* nxt;
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x) return;
  y = x->EnvironmentId;
  if (!y) return;
  x->EnvironmentId = 0;
  while (y) {
    nxt = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n;
    y->gg.g.n = &x->EnvironmentId->gg.g;
    x->EnvironmentId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_EnvironmentId) */

void zx_hrxml_WorkSiteEnvironment_PUT_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_EnvironmentId_s* z)
{
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x || !z) return;
  y = x->EnvironmentId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->EnvironmentId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_EnvironmentId) */

void zx_hrxml_WorkSiteEnvironment_ADD_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_EnvironmentId_s* z)
{
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->EnvironmentId->gg.g;
    x->EnvironmentId = z;
    return;
  case -1:
    y = x->EnvironmentId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EnvironmentId; n > 1 && y; --n, y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_EnvironmentId) */

void zx_hrxml_WorkSiteEnvironment_DEL_EnvironmentId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_EnvironmentId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->EnvironmentId = (struct zx_hrxml_EnvironmentId_s*)x->EnvironmentId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_EnvironmentId_s*)x->EnvironmentId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->EnvironmentId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_EnvironmentId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_WorkSiteId) */

int zx_hrxml_WorkSiteEnvironment_NUM_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_WorkSiteId_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->WorkSiteId; y; ++n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_WorkSiteId) */

struct zx_hrxml_WorkSiteId_s* zx_hrxml_WorkSiteEnvironment_GET_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return 0;
  for (y = x->WorkSiteId; n>=0 && y; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_WorkSiteId) */

struct zx_hrxml_WorkSiteId_s* zx_hrxml_WorkSiteEnvironment_POP_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return 0;
  y = x->WorkSiteId;
  if (y)
    x->WorkSiteId = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_WorkSiteId) */

void zx_hrxml_WorkSiteEnvironment_PUSH_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_hrxml_WorkSiteId_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->WorkSiteId->gg.g;
  x->WorkSiteId = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_WorkSiteId) */

void zx_hrxml_WorkSiteEnvironment_REV_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_WorkSiteId_s* nxt;
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return;
  y = x->WorkSiteId;
  if (!y) return;
  x->WorkSiteId = 0;
  while (y) {
    nxt = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n;
    y->gg.g.n = &x->WorkSiteId->gg.g;
    x->WorkSiteId = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_WorkSiteId) */

void zx_hrxml_WorkSiteEnvironment_PUT_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_WorkSiteId_s* z)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x || !z) return;
  y = x->WorkSiteId;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->WorkSiteId = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_WorkSiteId) */

void zx_hrxml_WorkSiteEnvironment_ADD_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_WorkSiteId_s* z)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->WorkSiteId->gg.g;
    x->WorkSiteId = z;
    return;
  case -1:
    y = x->WorkSiteId;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteId; n > 1 && y; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_WorkSiteId) */

void zx_hrxml_WorkSiteEnvironment_DEL_WorkSiteId(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_WorkSiteId_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->WorkSiteId = (struct zx_hrxml_WorkSiteId_s*)x->WorkSiteId->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_WorkSiteId_s*)x->WorkSiteId;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->WorkSiteId; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_WorkSiteId_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_Description) */

int zx_hrxml_WorkSiteEnvironment_NUM_Description(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Description_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Description; y; ++n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_Description) */

struct zx_hrxml_Description_s* zx_hrxml_WorkSiteEnvironment_GET_Description(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  for (y = x->Description; n>=0 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_Description) */

struct zx_hrxml_Description_s* zx_hrxml_WorkSiteEnvironment_POP_Description(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return 0;
  y = x->Description;
  if (y)
    x->Description = (struct zx_hrxml_Description_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_Description) */

void zx_hrxml_WorkSiteEnvironment_PUSH_Description(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_hrxml_Description_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Description->gg.g;
  x->Description = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_Description) */

void zx_hrxml_WorkSiteEnvironment_REV_Description(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Description_s* nxt;
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  y = x->Description;
  if (!y) return;
  x->Description = 0;
  while (y) {
    nxt = (struct zx_hrxml_Description_s*)y->gg.g.n;
    y->gg.g.n = &x->Description->gg.g;
    x->Description = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_Description) */

void zx_hrxml_WorkSiteEnvironment_PUT_Description(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  y = x->Description;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Description = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_Description) */

void zx_hrxml_WorkSiteEnvironment_ADD_Description(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_Description_s* z)
{
  struct zx_hrxml_Description_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Description->gg.g;
    x->Description = z;
    return;
  case -1:
    y = x->Description;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_Description) */

void zx_hrxml_WorkSiteEnvironment_DEL_Description(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_Description_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Description = (struct zx_hrxml_Description_s*)x->Description->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Description_s*)x->Description;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Description; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Description_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_Considerations) */

int zx_hrxml_WorkSiteEnvironment_NUM_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Considerations_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->Considerations; y; ++n, y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_Considerations) */

struct zx_hrxml_Considerations_s* zx_hrxml_WorkSiteEnvironment_GET_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_Considerations_s* y;
  if (!x) return 0;
  for (y = x->Considerations; n>=0 && y; --n, y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_Considerations) */

struct zx_hrxml_Considerations_s* zx_hrxml_WorkSiteEnvironment_POP_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Considerations_s* y;
  if (!x) return 0;
  y = x->Considerations;
  if (y)
    x->Considerations = (struct zx_hrxml_Considerations_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_Considerations) */

void zx_hrxml_WorkSiteEnvironment_PUSH_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_hrxml_Considerations_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->Considerations->gg.g;
  x->Considerations = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_Considerations) */

void zx_hrxml_WorkSiteEnvironment_REV_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_Considerations_s* nxt;
  struct zx_hrxml_Considerations_s* y;
  if (!x) return;
  y = x->Considerations;
  if (!y) return;
  x->Considerations = 0;
  while (y) {
    nxt = (struct zx_hrxml_Considerations_s*)y->gg.g.n;
    y->gg.g.n = &x->Considerations->gg.g;
    x->Considerations = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_Considerations) */

void zx_hrxml_WorkSiteEnvironment_PUT_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_Considerations_s* z)
{
  struct zx_hrxml_Considerations_s* y;
  if (!x || !z) return;
  y = x->Considerations;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->Considerations = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_Considerations) */

void zx_hrxml_WorkSiteEnvironment_ADD_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_Considerations_s* z)
{
  struct zx_hrxml_Considerations_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->Considerations->gg.g;
    x->Considerations = z;
    return;
  case -1:
    y = x->Considerations;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Considerations; n > 1 && y; --n, y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_Considerations) */

void zx_hrxml_WorkSiteEnvironment_DEL_Considerations(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_Considerations_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->Considerations = (struct zx_hrxml_Considerations_s*)x->Considerations->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_Considerations_s*)x->Considerations;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->Considerations; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_Considerations_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif



#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteEnvironment_NUM_UserArea) */

int zx_hrxml_WorkSiteEnvironment_NUM_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->UserArea; y; ++n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_GET_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_WorkSiteEnvironment_GET_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  for (y = x->UserArea; n>=0 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_POP_UserArea) */

struct zx_hrxml_UserArea_s* zx_hrxml_WorkSiteEnvironment_POP_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return 0;
  y = x->UserArea;
  if (y)
    x->UserArea = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUSH_UserArea) */

void zx_hrxml_WorkSiteEnvironment_PUSH_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x, struct zx_hrxml_UserArea_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->UserArea->gg.g;
  x->UserArea = z;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_REV_UserArea) */

void zx_hrxml_WorkSiteEnvironment_REV_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x)
{
  struct zx_hrxml_UserArea_s* nxt;
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  y = x->UserArea;
  if (!y) return;
  x->UserArea = 0;
  while (y) {
    nxt = (struct zx_hrxml_UserArea_s*)y->gg.g.n;
    y->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_PUT_UserArea) */

void zx_hrxml_WorkSiteEnvironment_PUT_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  y = x->UserArea;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->UserArea = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_ADD_UserArea) */

void zx_hrxml_WorkSiteEnvironment_ADD_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x, int n, struct zx_hrxml_UserArea_s* z)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->UserArea->gg.g;
    x->UserArea = z;
    return;
  case -1:
    y = x->UserArea;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteEnvironment_DEL_UserArea) */

void zx_hrxml_WorkSiteEnvironment_DEL_UserArea(struct zx_hrxml_WorkSiteEnvironment_s* x, int n)
{
  struct zx_hrxml_UserArea_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->UserArea = (struct zx_hrxml_UserArea_s*)x->UserArea->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_UserArea_s*)x->UserArea;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->UserArea; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_UserArea_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif








#ifdef ZX_ENA_GETPUT

/* FUNC(zx_hrxml_WorkSiteId_NUM_IdValue) */

int zx_hrxml_WorkSiteId_NUM_IdValue(struct zx_hrxml_WorkSiteId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  int n = 0;
  if (!x) return 0;
  for (y = x->IdValue; y; ++n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return n;
}

/* FUNC(zx_hrxml_WorkSiteId_GET_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_WorkSiteId_GET_IdValue(struct zx_hrxml_WorkSiteId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  for (y = x->IdValue; n>=0 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteId_POP_IdValue) */

struct zx_hrxml_IdValue_s* zx_hrxml_WorkSiteId_POP_IdValue(struct zx_hrxml_WorkSiteId_s* x)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return 0;
  y = x->IdValue;
  if (y)
    x->IdValue = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
  return y;
}

/* FUNC(zx_hrxml_WorkSiteId_PUSH_IdValue) */

void zx_hrxml_WorkSiteId_PUSH_IdValue(struct zx_hrxml_WorkSiteId_s* x, struct zx_hrxml_IdValue_s* z)
{
  if (!x || !z) return;
  z->gg.g.n = &x->IdValue->gg.g;
  x->IdValue = z;
}

/* FUNC(zx_hrxml_WorkSiteId_REV_IdValue) */

void zx_hrxml_WorkSiteId_REV_IdValue(struct zx_hrxml_WorkSiteId_s* x)
{
  struct zx_hrxml_IdValue_s* nxt;
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  y = x->IdValue;
  if (!y) return;
  x->IdValue = 0;
  while (y) {
    nxt = (struct zx_hrxml_IdValue_s*)y->gg.g.n;
    y->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = y;
    y = nxt;
  }
}

/* FUNC(zx_hrxml_WorkSiteId_PUT_IdValue) */

void zx_hrxml_WorkSiteId_PUT_IdValue(struct zx_hrxml_WorkSiteId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  y = x->IdValue;
  if (!y) return;
  switch (n) {
  case 0:
    z->gg.g.n = y->gg.g.n;
    x->IdValue = z;
    return;
  default:
    for (; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
    z->gg.g.n = y->gg.g.n->n;
    y->gg.g.n = &z->gg.g;
  }
}

/* FUNC(zx_hrxml_WorkSiteId_ADD_IdValue) */

void zx_hrxml_WorkSiteId_ADD_IdValue(struct zx_hrxml_WorkSiteId_s* x, int n, struct zx_hrxml_IdValue_s* z)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x || !z) return;
  switch (n) {
  case 0:
  add_to_start:
    z->gg.g.n = &x->IdValue->gg.g;
    x->IdValue = z;
    return;
  case -1:
    y = x->IdValue;
    if (!y) goto add_to_start;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y) return;
  }
  z->gg.g.n = y->gg.g.n;
  y->gg.g.n = &z->gg.g;
}

/* FUNC(zx_hrxml_WorkSiteId_DEL_IdValue) */

void zx_hrxml_WorkSiteId_DEL_IdValue(struct zx_hrxml_WorkSiteId_s* x, int n)
{
  struct zx_hrxml_IdValue_s* y;
  if (!x) return;
  switch (n) {
  case 0:
    x->IdValue = (struct zx_hrxml_IdValue_s*)x->IdValue->gg.g.n;
    return;
  case -1:
    y = (struct zx_hrxml_IdValue_s*)x->IdValue;
    if (!y) return;
    for (; y->gg.g.n; y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    break;
  default:
    for (y = x->IdValue; n > 1 && y->gg.g.n; --n, y = (struct zx_hrxml_IdValue_s*)y->gg.g.n) ;
    if (!y->gg.g.n) return;
  }
  y->gg.g.n = y->gg.g.n->n;
}

#endif

/* FUNC(zx_hrxml_WorkSiteId_GET_idOwner) */
struct zx_str* zx_hrxml_WorkSiteId_GET_idOwner(struct zx_hrxml_WorkSiteId_s* x) { return x->idOwner; }
/* FUNC(zx_hrxml_WorkSiteId_PUT_idOwner) */
void zx_hrxml_WorkSiteId_PUT_idOwner(struct zx_hrxml_WorkSiteId_s* x, struct zx_str* y) { x->idOwner = y; }
/* FUNC(zx_hrxml_WorkSiteId_GET_validFrom) */
struct zx_str* zx_hrxml_WorkSiteId_GET_validFrom(struct zx_hrxml_WorkSiteId_s* x) { return x->validFrom; }
/* FUNC(zx_hrxml_WorkSiteId_PUT_validFrom) */
void zx_hrxml_WorkSiteId_PUT_validFrom(struct zx_hrxml_WorkSiteId_s* x, struct zx_str* y) { x->validFrom = y; }
/* FUNC(zx_hrxml_WorkSiteId_GET_validTo) */
struct zx_str* zx_hrxml_WorkSiteId_GET_validTo(struct zx_hrxml_WorkSiteId_s* x) { return x->validTo; }
/* FUNC(zx_hrxml_WorkSiteId_PUT_validTo) */
void zx_hrxml_WorkSiteId_PUT_validTo(struct zx_hrxml_WorkSiteId_s* x, struct zx_str* y) { x->validTo = y; }





/* EOF -- c/zx-hrxml-getput.c */
