/* ==========================================================*/;
/*  Author: Jan Goebel                                       */;
/*    Date:  Wed Dec 4 17:41:45 CET 2013                    */;
/*                                                           */;
/*  This script converts the "normal" SOEP data files        */;
/*  (100 or 95%) into the SOEP Teaching Version (50 %)       */;
/*                                                           */;
/* IMPORTANT NOTE: copy *BY HAND* the formats file from the  */;
/*                 'soep' dir to the 'school' dir            */;
/* ==========================================================*/;


/* =========================================== */;
/* Here you can define the correct directories */;
/* Note the trailing slashes!                  */;
/* If you define soepdatadir and schooldatadir */;
/* to be the same the original SOEP data       */;
/* will be OVERWRITTEN with the teaching       */;
/* version!!!                                  */;
/* =========================================== */;

libname   soep    '/daten/user/soepdist/make_v29/data_de/sas/'  ;
libname   library '/daten/user/soepdist/make_v29/data_de/sas/'  ;
libname   school  './sas50/';

/*        --------------------------------------------------------------- */;
/*        Get CIRDEF sorted and ready for merge                           */;
data      cirdef;
 set      soep.cirdef;
 proc     sort; by hhnr;
run;

DATA     hconsum;
 SET      soep.hconsum;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hconsum(label="SOEP.v29@school: hconsum");
 MERGE    hconsum (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     abroad;
 SET      soep.abroad;
 PROC SORT; BY hhnr;
RUN;
DATA      school.abroad(label="SOEP.v29@school: abroad");
 MERGE    abroad (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ah;
 SET      soep.ah;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ah(label="SOEP.v29@school: ah");
 MERGE    ah (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ahbrutto;
 SET      soep.ahbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ahbrutto(label="SOEP.v29@school: ahbrutto");
 MERGE    ahbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ahgen;
 SET      soep.ahgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ahgen(label="SOEP.v29@school: ahgen");
 MERGE    ahgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     akind;
 SET      soep.akind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.akind(label="SOEP.v29@school: akind");
 MERGE    akind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ap;
 SET      soep.ap;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ap(label="SOEP.v29@school: ap");
 MERGE    ap (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     apausl;
 SET      soep.apausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.apausl(label="SOEP.v29@school: apausl");
 MERGE    apausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     apbrutto;
 SET      soep.apbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.apbrutto(label="SOEP.v29@school: apbrutto");
 MERGE    apbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     apequiv;
 SET      soep.apequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.apequiv(label="SOEP.v29@school: apequiv");
 MERGE    apequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     apgen;
 SET      soep.apgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.apgen(label="SOEP.v29@school: apgen");
 MERGE    apgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     apkal;
 SET      soep.apkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.apkal(label="SOEP.v29@school: apkal");
 MERGE    apkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     artkalen;
 SET      soep.artkalen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.artkalen(label="SOEP.v29@school: artkalen");
 MERGE    artkalen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bah;
 SET      soep.bah;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bah(label="SOEP.v29@school: bah");
 MERGE    bah (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bahbrutto;
 SET      soep.bahbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bahbrutto(label="SOEP.v29@school: bahbrutto");
 MERGE    bahbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bahgen;
 SET      soep.bahgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bahgen(label="SOEP.v29@school: bahgen");
 MERGE    bahgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bakind;
 SET      soep.bakind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bakind(label="SOEP.v29@school: bakind");
 MERGE    bakind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bap;
 SET      soep.bap;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bap(label="SOEP.v29@school: bap");
 MERGE    bap (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapage17;
 SET      soep.bapage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapage17(label="SOEP.v29@school: bapage17");
 MERGE    bapage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapbrutto;
 SET      soep.bapbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapbrutto(label="SOEP.v29@school: bapbrutto");
 MERGE    bapbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapequiv;
 SET      soep.bapequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapequiv(label="SOEP.v29@school: bapequiv");
 MERGE    bapequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapgen;
 SET      soep.bapgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapgen(label="SOEP.v29@school: bapgen");
 MERGE    bapgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapkal;
 SET      soep.bapkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapkal(label="SOEP.v29@school: bapkal");
 MERGE    bapkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bapluecke;
 SET      soep.bapluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bapluecke(label="SOEP.v29@school: bapluecke");
 MERGE    bapluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bavp;
 SET      soep.bavp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bavp(label="SOEP.v29@school: bavp");
 MERGE    bavp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbh;
 SET      soep.bbh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbh(label="SOEP.v29@school: bbh");
 MERGE    bbh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbhbrutto;
 SET      soep.bbhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbhbrutto(label="SOEP.v29@school: bbhbrutto");
 MERGE    bbhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbhgen;
 SET      soep.bbhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbhgen(label="SOEP.v29@school: bbhgen");
 MERGE    bbhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbkind;
 SET      soep.bbkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbkind(label="SOEP.v29@school: bbkind");
 MERGE    bbkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbp;
 SET      soep.bbp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbp(label="SOEP.v29@school: bbp");
 MERGE    bbp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpage17;
 SET      soep.bbpage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpage17(label="SOEP.v29@school: bbpage17");
 MERGE    bbpage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpbrutto;
 SET      soep.bbpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpbrutto(label="SOEP.v29@school: bbpbrutto");
 MERGE    bbpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpequiv;
 SET      soep.bbpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpequiv(label="SOEP.v29@school: bbpequiv");
 MERGE    bbpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpgen;
 SET      soep.bbpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpgen(label="SOEP.v29@school: bbpgen");
 MERGE    bbpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpkal;
 SET      soep.bbpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpkal(label="SOEP.v29@school: bbpkal");
 MERGE    bbpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbpluecke;
 SET      soep.bbpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbpluecke(label="SOEP.v29@school: bbpluecke");
 MERGE    bbpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bbvp;
 SET      soep.bbvp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bbvp(label="SOEP.v29@school: bbvp");
 MERGE    bbvp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bch;
 SET      soep.bch;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bch(label="SOEP.v29@school: bch");
 MERGE    bch (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bchbrutto;
 SET      soep.bchbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bchbrutto(label="SOEP.v29@school: bchbrutto");
 MERGE    bchbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bchgen;
 SET      soep.bchgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bchgen(label="SOEP.v29@school: bchgen");
 MERGE    bchgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bckind;
 SET      soep.bckind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bckind(label="SOEP.v29@school: bckind");
 MERGE    bckind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcp;
 SET      soep.bcp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcp(label="SOEP.v29@school: bcp");
 MERGE    bcp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcpage17;
 SET      soep.bcpage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcpage17(label="SOEP.v29@school: bcpage17");
 MERGE    bcpage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcpbrutto;
 SET      soep.bcpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcpbrutto(label="SOEP.v29@school: bcpbrutto");
 MERGE    bcpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcpgen;
 SET      soep.bcpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcpgen(label="SOEP.v29@school: bcpgen");
 MERGE    bcpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcpkal;
 SET      soep.bcpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcpkal(label="SOEP.v29@school: bcpkal");
 MERGE    bcpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcpequiv;
 SET      soep.bcpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcpequiv(label="SOEP.v29@school: bcpequiv");
 MERGE    bcpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bcvp;
 SET      soep.bcvp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bcvp(label="SOEP.v29@school: bcvp");
 MERGE    bcvp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bh;
 SET      soep.bh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bh(label="SOEP.v29@school: bh");
 MERGE    bh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bhbrutto;
 SET      soep.bhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bhbrutto(label="SOEP.v29@school: bhbrutto");
 MERGE    bhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bhgen;
 SET      soep.bhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bhgen(label="SOEP.v29@school: bhgen");
 MERGE    bhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage01;
 SET      soep.bioage01;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage01(label="SOEP.v29@school: bioage01");
 MERGE    bioage01 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage03;
 SET      soep.bioage03;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage03(label="SOEP.v29@school: bioage03");
 MERGE    bioage03 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage06;
 SET      soep.bioage06;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage06(label="SOEP.v29@school: bioage06");
 MERGE    bioage06 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage08a;
 SET      soep.bioage08a;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage08a(label="SOEP.v29@school: bioage08a");
 MERGE    bioage08a (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage08b;
 SET      soep.bioage08b;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage08b(label="SOEP.v29@school: bioage08b");
 MERGE    bioage08b (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage10;
 SET      soep.bioage10;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage10(label="SOEP.v29@school: bioage10");
 MERGE    bioage10 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioage17;
 SET      soep.bioage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioage17(label="SOEP.v29@school: bioage17");
 MERGE    bioage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioagel;
 SET      soep.bioagel;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioagel(label="SOEP.v29@school: bioagel");
 MERGE    bioagel (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biobirth;
 SET      soep.biobirth;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biobirth(label="SOEP.v29@school: biobirth");
 MERGE    biobirth (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biobrthm;
 SET      soep.biobrthm;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biobrthm(label="SOEP.v29@school: biobrthm");
 MERGE    biobrthm (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biocouplm;
 SET      soep.biocouplm;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biocouplm(label="SOEP.v29@school: biocouplm");
 MERGE    biocouplm (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biocouply;
 SET      soep.biocouply;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biocouply(label="SOEP.v29@school: biocouply");
 MERGE    biocouply (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioedu;
 SET      soep.bioedu;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioedu(label="SOEP.v29@school: bioedu");
 MERGE    bioedu (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioimmig;
 SET      soep.bioimmig;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioimmig(label="SOEP.v29@school: bioimmig");
 MERGE    bioimmig (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biojob;
 SET      soep.biojob;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biojob(label="SOEP.v29@school: biojob");
 MERGE    biojob (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biomarsm;
 SET      soep.biomarsm;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biomarsm(label="SOEP.v29@school: biomarsm");
 MERGE    biomarsm (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biomarsy;
 SET      soep.biomarsy;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biomarsy(label="SOEP.v29@school: biomarsy");
 MERGE    biomarsy (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioparen;
 SET      soep.bioparen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioparen(label="SOEP.v29@school: bioparen");
 MERGE    bioparen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bioresid;
 SET      soep.bioresid;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bioresid(label="SOEP.v29@school: bioresid");
 MERGE    bioresid (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biosib;
 SET      soep.biosib;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biosib(label="SOEP.v29@school: biosib");
 MERGE    biosib (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biosoc;
 SET      soep.biosoc;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biosoc(label="SOEP.v29@school: biosoc");
 MERGE    biosoc (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     biotwin;
 SET      soep.biotwin;
 PROC SORT; BY hhnr;
RUN;
DATA      school.biotwin(label="SOEP.v29@school: biotwin");
 MERGE    biotwin (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bkind;
 SET      soep.bkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bkind(label="SOEP.v29@school: bkind");
 MERGE    bkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bp;
 SET      soep.bp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bp(label="SOEP.v29@school: bp");
 MERGE    bp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpausl;
 SET      soep.bpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpausl(label="SOEP.v29@school: bpausl");
 MERGE    bpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpbrutto;
 SET      soep.bpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpbrutto(label="SOEP.v29@school: bpbrutto");
 MERGE    bpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpequiv;
 SET      soep.bpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpequiv(label="SOEP.v29@school: bpequiv");
 MERGE    bpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpgen;
 SET      soep.bpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpgen(label="SOEP.v29@school: bpgen");
 MERGE    bpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpkal;
 SET      soep.bpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpkal(label="SOEP.v29@school: bpkal");
 MERGE    bpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     bpluecke;
 SET      soep.bpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.bpluecke(label="SOEP.v29@school: bpluecke");
 MERGE    bpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ch;
 SET      soep.ch;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ch(label="SOEP.v29@school: ch");
 MERGE    ch (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     chbrutto;
 SET      soep.chbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.chbrutto(label="SOEP.v29@school: chbrutto");
 MERGE    chbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     chgen;
 SET      soep.chgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.chgen(label="SOEP.v29@school: chgen");
 MERGE    chgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cirdef;
 SET      soep.cirdef;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cirdef(label="SOEP.v29@school: cirdef");
 MERGE    cirdef (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ckind;
 SET      soep.ckind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ckind(label="SOEP.v29@school: ckind");
 MERGE    ckind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cogdj;
 SET      soep.cogdj;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cogdj(label="SOEP.v29@school: cogdj");
 MERGE    cogdj (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cognit;
 SET      soep.cognit;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cognit(label="SOEP.v29@school: cognit");
 MERGE    cognit (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cp;
 SET      soep.cp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cp(label="SOEP.v29@school: cp");
 MERGE    cp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpausl;
 SET      soep.cpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpausl(label="SOEP.v29@school: cpausl");
 MERGE    cpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpbrutto;
 SET      soep.cpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpbrutto(label="SOEP.v29@school: cpbrutto");
 MERGE    cpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpequiv;
 SET      soep.cpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpequiv(label="SOEP.v29@school: cpequiv");
 MERGE    cpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpgen;
 SET      soep.cpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpgen(label="SOEP.v29@school: cpgen");
 MERGE    cpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpkal;
 SET      soep.cpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpkal(label="SOEP.v29@school: cpkal");
 MERGE    cpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     cpluecke;
 SET      soep.cpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.cpluecke(label="SOEP.v29@school: cpluecke");
 MERGE    cpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     design;
 SET      soep.design;
 PROC SORT; BY hhnr;
RUN;
DATA      school.design(label="SOEP.v29@school: design");
 MERGE    design (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dh;
 SET      soep.dh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dh(label="SOEP.v29@school: dh");
 MERGE    dh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dhbrutto;
 SET      soep.dhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dhbrutto(label="SOEP.v29@school: dhbrutto");
 MERGE    dhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dhgen;
 SET      soep.dhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dhgen(label="SOEP.v29@school: dhgen");
 MERGE    dhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dkind;
 SET      soep.dkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dkind(label="SOEP.v29@school: dkind");
 MERGE    dkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dp;
 SET      soep.dp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dp(label="SOEP.v29@school: dp");
 MERGE    dp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpausl;
 SET      soep.dpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpausl(label="SOEP.v29@school: dpausl");
 MERGE    dpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpbrutto;
 SET      soep.dpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpbrutto(label="SOEP.v29@school: dpbrutto");
 MERGE    dpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpequiv;
 SET      soep.dpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpequiv(label="SOEP.v29@school: dpequiv");
 MERGE    dpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpgen;
 SET      soep.dpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpgen(label="SOEP.v29@school: dpgen");
 MERGE    dpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpkal;
 SET      soep.dpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpkal(label="SOEP.v29@school: dpkal");
 MERGE    dpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     dpluecke;
 SET      soep.dpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.dpluecke(label="SOEP.v29@school: dpluecke");
 MERGE    dpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     eh;
 SET      soep.eh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.eh(label="SOEP.v29@school: eh");
 MERGE    eh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ehbrutto;
 SET      soep.ehbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ehbrutto(label="SOEP.v29@school: ehbrutto");
 MERGE    ehbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ehgen;
 SET      soep.ehgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ehgen(label="SOEP.v29@school: ehgen");
 MERGE    ehgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     einkalen;
 SET      soep.einkalen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.einkalen(label="SOEP.v29@school: einkalen");
 MERGE    einkalen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ekind;
 SET      soep.ekind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ekind(label="SOEP.v29@school: ekind");
 MERGE    ekind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ep;
 SET      soep.ep;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ep(label="SOEP.v29@school: ep");
 MERGE    ep (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epausl;
 SET      soep.epausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epausl(label="SOEP.v29@school: epausl");
 MERGE    epausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epbrutto;
 SET      soep.epbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epbrutto(label="SOEP.v29@school: epbrutto");
 MERGE    epbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epequiv;
 SET      soep.epequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epequiv(label="SOEP.v29@school: epequiv");
 MERGE    epequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epgen;
 SET      soep.epgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epgen(label="SOEP.v29@school: epgen");
 MERGE    epgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epkal;
 SET      soep.epkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epkal(label="SOEP.v29@school: epkal");
 MERGE    epkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     epluecke;
 SET      soep.epluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.epluecke(label="SOEP.v29@school: epluecke");
 MERGE    epluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ev;
 SET      soep.ev;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ev(label="SOEP.v29@school: ev");
 MERGE    ev (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     exit;
 SET      soep.exit;
 PROC SORT; BY hhnr;
RUN;
DATA      school.exit(label="SOEP.v29@school: exit");
 MERGE    exit (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fh;
 SET      soep.fh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fh(label="SOEP.v29@school: fh");
 MERGE    fh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fhbrutto;
 SET      soep.fhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fhbrutto(label="SOEP.v29@school: fhbrutto");
 MERGE    fhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fhgen;
 SET      soep.fhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fhgen(label="SOEP.v29@school: fhgen");
 MERGE    fhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fkind;
 SET      soep.fkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fkind(label="SOEP.v29@school: fkind");
 MERGE    fkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fp;
 SET      soep.fp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fp(label="SOEP.v29@school: fp");
 MERGE    fp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpausl;
 SET      soep.fpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpausl(label="SOEP.v29@school: fpausl");
 MERGE    fpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpbrutto;
 SET      soep.fpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpbrutto(label="SOEP.v29@school: fpbrutto");
 MERGE    fpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpequiv;
 SET      soep.fpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpequiv(label="SOEP.v29@school: fpequiv");
 MERGE    fpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpgen;
 SET      soep.fpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpgen(label="SOEP.v29@school: fpgen");
 MERGE    fpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpkal;
 SET      soep.fpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpkal(label="SOEP.v29@school: fpkal");
 MERGE    fpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     fpluecke;
 SET      soep.fpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.fpluecke(label="SOEP.v29@school: fpluecke");
 MERGE    fpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gh;
 SET      soep.gh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gh(label="SOEP.v29@school: gh");
 MERGE    gh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ghbrutto;
 SET      soep.ghbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ghbrutto(label="SOEP.v29@school: ghbrutto");
 MERGE    ghbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ghgen;
 SET      soep.ghgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ghgen(label="SOEP.v29@school: ghgen");
 MERGE    ghgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ghost;
 SET      soep.ghost;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ghost(label="SOEP.v29@school: ghost");
 MERGE    ghost (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gkind;
 SET      soep.gkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gkind(label="SOEP.v29@school: gkind");
 MERGE    gkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gp;
 SET      soep.gp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gp(label="SOEP.v29@school: gp");
 MERGE    gp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpausl;
 SET      soep.gpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpausl(label="SOEP.v29@school: gpausl");
 MERGE    gpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpbrutto;
 SET      soep.gpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpbrutto(label="SOEP.v29@school: gpbrutto");
 MERGE    gpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpequiv;
 SET      soep.gpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpequiv(label="SOEP.v29@school: gpequiv");
 MERGE    gpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpgen;
 SET      soep.gpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpgen(label="SOEP.v29@school: gpgen");
 MERGE    gpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpkal;
 SET      soep.gpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpkal(label="SOEP.v29@school: gpkal");
 MERGE    gpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpkalost;
 SET      soep.gpkalost;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpkalost(label="SOEP.v29@school: gpkalost");
 MERGE    gpkalost (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpluecke;
 SET      soep.gpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpluecke(label="SOEP.v29@school: gpluecke");
 MERGE    gpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gpost;
 SET      soep.gpost;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gpost(label="SOEP.v29@school: gpost");
 MERGE    gpost (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     gripstr;
 SET      soep.gripstr;
 PROC SORT; BY hhnr;
RUN;
DATA      school.gripstr(label="SOEP.v29@school: gripstr");
 MERGE    gripstr (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt00;
 SET      soep.hbrutt00;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt00(label="SOEP.v29@school: hbrutt00");
 MERGE    hbrutt00 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt02;
 SET      soep.hbrutt02;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt02(label="SOEP.v29@school: hbrutt02");
 MERGE    hbrutt02 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt06;
 SET      soep.hbrutt06;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt06(label="SOEP.v29@school: hbrutt06");
 MERGE    hbrutt06 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt09;
 SET      soep.hbrutt09;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt09(label="SOEP.v29@school: hbrutt09");
 MERGE    hbrutt09 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt11;
 SET      soep.hbrutt11;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt11(label="SOEP.v29@school: hbrutt11");
 MERGE    hbrutt11 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt12;
 SET      soep.hbrutt12;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt12(label="SOEP.v29@school: hbrutt12");
 MERGE    hbrutt12 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt84;
 SET      soep.hbrutt84;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt84(label="SOEP.v29@school: hbrutt84");
 MERGE    hbrutt84 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hbrutt98;
 SET      soep.hbrutt98;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hbrutt98(label="SOEP.v29@school: hbrutt98");
 MERGE    hbrutt98 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     health;
 SET      soep.health;
 PROC SORT; BY hhnr;
RUN;
DATA      school.health(label="SOEP.v29@school: health");
 MERGE    health (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hh;
 SET      soep.hh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hh(label="SOEP.v29@school: hh");
 MERGE    hh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hhbrutto;
 SET      soep.hhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hhbrutto(label="SOEP.v29@school: hhbrutto");
 MERGE    hhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hhgen;
 SET      soep.hhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hhgen(label="SOEP.v29@school: hhgen");
 MERGE    hhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hhrf;
 SET      soep.hhrf;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hhrf(label="SOEP.v29@school: hhrf");
 MERGE    hhrf (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hkind;
 SET      soep.hkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hkind(label="SOEP.v29@school: hkind");
 MERGE    hkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hp;
 SET      soep.hp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hp(label="SOEP.v29@school: hp");
 MERGE    hp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpausl;
 SET      soep.hpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpausl(label="SOEP.v29@school: hpausl");
 MERGE    hpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpbrutto;
 SET      soep.hpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpbrutto(label="SOEP.v29@school: hpbrutto");
 MERGE    hpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpequiv;
 SET      soep.hpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpequiv(label="SOEP.v29@school: hpequiv");
 MERGE    hpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpfad;
 SET      soep.hpfad;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpfad(label="SOEP.v29@school: hpfad");
 MERGE    hpfad (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpgen;
 SET      soep.hpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpgen(label="SOEP.v29@school: hpgen");
 MERGE    hpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpkal;
 SET      soep.hpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpkal(label="SOEP.v29@school: hpkal");
 MERGE    hpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpkalost;
 SET      soep.hpkalost;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpkalost(label="SOEP.v29@school: hpkalost");
 MERGE    hpkalost (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpluecke;
 SET      soep.hpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpluecke(label="SOEP.v29@school: hpluecke");
 MERGE    hpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hpost;
 SET      soep.hpost;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hpost(label="SOEP.v29@school: hpost");
 MERGE    hpost (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     hwealth;
 SET      soep.hwealth;
 PROC SORT; BY hhnr;
RUN;
DATA      school.hwealth(label="SOEP.v29@school: hwealth");
 MERGE    hwealth (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ih;
 SET      soep.ih;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ih(label="SOEP.v29@school: ih");
 MERGE    ih (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ihbrutto;
 SET      soep.ihbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ihbrutto(label="SOEP.v29@school: ihbrutto");
 MERGE    ihbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ihgen;
 SET      soep.ihgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ihgen(label="SOEP.v29@school: ihgen");
 MERGE    ihgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ikind;
 SET      soep.ikind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ikind(label="SOEP.v29@school: ikind");
 MERGE    ikind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     intview;
 SET      soep.intview;
 PROC SORT; BY hhnr;
RUN;
DATA      school.intview(label="SOEP.v29@school: intview");
 MERGE    intview (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ip;
 SET      soep.ip;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ip(label="SOEP.v29@school: ip");
 MERGE    ip (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipausl;
 SET      soep.ipausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipausl(label="SOEP.v29@school: ipausl");
 MERGE    ipausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipbrutto;
 SET      soep.ipbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipbrutto(label="SOEP.v29@school: ipbrutto");
 MERGE    ipbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipequiv;
 SET      soep.ipequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipequiv(label="SOEP.v29@school: ipequiv");
 MERGE    ipequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipgen;
 SET      soep.ipgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipgen(label="SOEP.v29@school: ipgen");
 MERGE    ipgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipkal;
 SET      soep.ipkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipkal(label="SOEP.v29@school: ipkal");
 MERGE    ipkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ipluecke;
 SET      soep.ipluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ipluecke(label="SOEP.v29@school: ipluecke");
 MERGE    ipluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jh;
 SET      soep.jh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jh(label="SOEP.v29@school: jh");
 MERGE    jh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jhbrutto;
 SET      soep.jhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jhbrutto(label="SOEP.v29@school: jhbrutto");
 MERGE    jhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jhgen;
 SET      soep.jhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jhgen(label="SOEP.v29@school: jhgen");
 MERGE    jhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jkind;
 SET      soep.jkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jkind(label="SOEP.v29@school: jkind");
 MERGE    jkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jp;
 SET      soep.jp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jp(label="SOEP.v29@school: jp");
 MERGE    jp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpausl;
 SET      soep.jpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpausl(label="SOEP.v29@school: jpausl");
 MERGE    jpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpbrutto;
 SET      soep.jpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpbrutto(label="SOEP.v29@school: jpbrutto");
 MERGE    jpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpequiv;
 SET      soep.jpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpequiv(label="SOEP.v29@school: jpequiv");
 MERGE    jpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpgen;
 SET      soep.jpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpgen(label="SOEP.v29@school: jpgen");
 MERGE    jpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpkal;
 SET      soep.jpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpkal(label="SOEP.v29@school: jpkal");
 MERGE    jpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     jpluecke;
 SET      soep.jpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.jpluecke(label="SOEP.v29@school: jpluecke");
 MERGE    jpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kh;
 SET      soep.kh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kh(label="SOEP.v29@school: kh");
 MERGE    kh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     khbrutto;
 SET      soep.khbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.khbrutto(label="SOEP.v29@school: khbrutto");
 MERGE    khbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     khgen;
 SET      soep.khgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.khgen(label="SOEP.v29@school: khgen");
 MERGE    khgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kidlong;
 SET      soep.kidlong;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kidlong(label="SOEP.v29@school: kidlong");
 MERGE    kidlong (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kkind;
 SET      soep.kkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kkind(label="SOEP.v29@school: kkind");
 MERGE    kkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kp;
 SET      soep.kp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kp(label="SOEP.v29@school: kp");
 MERGE    kp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpausl;
 SET      soep.kpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpausl(label="SOEP.v29@school: kpausl");
 MERGE    kpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpbrutto;
 SET      soep.kpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpbrutto(label="SOEP.v29@school: kpbrutto");
 MERGE    kpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpequiv;
 SET      soep.kpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpequiv(label="SOEP.v29@school: kpequiv");
 MERGE    kpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpgen;
 SET      soep.kpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpgen(label="SOEP.v29@school: kpgen");
 MERGE    kpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpkal;
 SET      soep.kpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpkal(label="SOEP.v29@school: kpkal");
 MERGE    kpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     kpluecke;
 SET      soep.kpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.kpluecke(label="SOEP.v29@school: kpluecke");
 MERGE    kpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lh;
 SET      soep.lh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lh(label="SOEP.v29@school: lh");
 MERGE    lh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lhbrutto;
 SET      soep.lhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lhbrutto(label="SOEP.v29@school: lhbrutto");
 MERGE    lhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lhgen;
 SET      soep.lhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lhgen(label="SOEP.v29@school: lhgen");
 MERGE    lhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lifespell;
 SET      soep.lifespell;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lifespell(label="SOEP.v29@school: lifespell");
 MERGE    lifespell (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lkind;
 SET      soep.lkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lkind(label="SOEP.v29@school: lkind");
 MERGE    lkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lp;
 SET      soep.lp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lp(label="SOEP.v29@school: lp");
 MERGE    lp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpausl;
 SET      soep.lpausl;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpausl(label="SOEP.v29@school: lpausl");
 MERGE    lpausl (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpbrutto;
 SET      soep.lpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpbrutto(label="SOEP.v29@school: lpbrutto");
 MERGE    lpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpequiv;
 SET      soep.lpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpequiv(label="SOEP.v29@school: lpequiv");
 MERGE    lpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpgen;
 SET      soep.lpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpgen(label="SOEP.v29@school: lpgen");
 MERGE    lpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpkal;
 SET      soep.lpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpkal(label="SOEP.v29@school: lpkal");
 MERGE    lpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     lpluecke;
 SET      soep.lpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.lpluecke(label="SOEP.v29@school: lpluecke");
 MERGE    lpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mh;
 SET      soep.mh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mh(label="SOEP.v29@school: mh");
 MERGE    mh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mhbrutto;
 SET      soep.mhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mhbrutto(label="SOEP.v29@school: mhbrutto");
 MERGE    mhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mhgen;
 SET      soep.mhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mhgen(label="SOEP.v29@school: mhgen");
 MERGE    mhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mihinc;
 SET      soep.mihinc;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mihinc(label="SOEP.v29@school: mihinc");
 MERGE    mihinc (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mkind;
 SET      soep.mkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mkind(label="SOEP.v29@school: mkind");
 MERGE    mkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mp;
 SET      soep.mp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mp(label="SOEP.v29@school: mp");
 MERGE    mp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mpbrutto;
 SET      soep.mpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mpbrutto(label="SOEP.v29@school: mpbrutto");
 MERGE    mpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mpequiv;
 SET      soep.mpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mpequiv(label="SOEP.v29@school: mpequiv");
 MERGE    mpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mpgen;
 SET      soep.mpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mpgen(label="SOEP.v29@school: mpgen");
 MERGE    mpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mpkal;
 SET      soep.mpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mpkal(label="SOEP.v29@school: mpkal");
 MERGE    mpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     mpluecke;
 SET      soep.mpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.mpluecke(label="SOEP.v29@school: mpluecke");
 MERGE    mpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     nh;
 SET      soep.nh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.nh(label="SOEP.v29@school: nh");
 MERGE    nh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     nhbrutto;
 SET      soep.nhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.nhbrutto(label="SOEP.v29@school: nhbrutto");
 MERGE    nhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     nhgen;
 SET      soep.nhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.nhgen(label="SOEP.v29@school: nhgen");
 MERGE    nhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     nkind;
 SET      soep.nkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.nkind(label="SOEP.v29@school: nkind");
 MERGE    nkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     np;
 SET      soep.np;
 PROC SORT; BY hhnr;
RUN;
DATA      school.np(label="SOEP.v29@school: np");
 MERGE    np (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     npbrutto;
 SET      soep.npbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.npbrutto(label="SOEP.v29@school: npbrutto");
 MERGE    npbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     npequiv;
 SET      soep.npequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.npequiv(label="SOEP.v29@school: npequiv");
 MERGE    npequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     npgen;
 SET      soep.npgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.npgen(label="SOEP.v29@school: npgen");
 MERGE    npgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     npkal;
 SET      soep.npkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.npkal(label="SOEP.v29@school: npkal");
 MERGE    npkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     npluecke;
 SET      soep.npluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.npluecke(label="SOEP.v29@school: npluecke");
 MERGE    npluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     oh;
 SET      soep.oh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.oh(label="SOEP.v29@school: oh");
 MERGE    oh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ohbrutto;
 SET      soep.ohbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ohbrutto(label="SOEP.v29@school: ohbrutto");
 MERGE    ohbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ohgen;
 SET      soep.ohgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ohgen(label="SOEP.v29@school: ohgen");
 MERGE    ohgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     okind;
 SET      soep.okind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.okind(label="SOEP.v29@school: okind");
 MERGE    okind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     op;
 SET      soep.op;
 PROC SORT; BY hhnr;
RUN;
DATA      school.op(label="SOEP.v29@school: op");
 MERGE    op (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     opbrutto;
 SET      soep.opbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.opbrutto(label="SOEP.v29@school: opbrutto");
 MERGE    opbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     opequiv;
 SET      soep.opequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.opequiv(label="SOEP.v29@school: opequiv");
 MERGE    opequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     opgen;
 SET      soep.opgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.opgen(label="SOEP.v29@school: opgen");
 MERGE    opgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     opkal;
 SET      soep.opkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.opkal(label="SOEP.v29@school: opkal");
 MERGE    opkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     opluecke;
 SET      soep.opluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.opluecke(label="SOEP.v29@school: opluecke");
 MERGE    opluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pbiospe;
 SET      soep.pbiospe;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pbiospe(label="SOEP.v29@school: pbiospe");
 MERGE    pbiospe (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pbr_exit;
 SET      soep.pbr_exit;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pbr_exit(label="SOEP.v29@school: pbr_exit");
 MERGE    pbr_exit (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pbr_hhch;
 SET      soep.pbr_hhch;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pbr_hhch(label="SOEP.v29@school: pbr_hhch");
 MERGE    pbr_hhch (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pflege;
 SET      soep.pflege;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pflege(label="SOEP.v29@school: pflege");
 MERGE    pflege (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ph;
 SET      soep.ph;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ph(label="SOEP.v29@school: ph");
 MERGE    ph (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     phbrutto;
 SET      soep.phbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.phbrutto(label="SOEP.v29@school: phbrutto");
 MERGE    phbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     phgen;
 SET      soep.phgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.phgen(label="SOEP.v29@school: phgen");
 MERGE    phgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     phrf;
 SET      soep.phrf;
 PROC SORT; BY hhnr;
RUN;
DATA      school.phrf(label="SOEP.v29@school: phrf");
 MERGE    phrf (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pkind;
 SET      soep.pkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pkind(label="SOEP.v29@school: pkind");
 MERGE    pkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pp;
 SET      soep.pp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pp(label="SOEP.v29@school: pp");
 MERGE    pp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppbrutto;
 SET      soep.ppbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppbrutto(label="SOEP.v29@school: ppbrutto");
 MERGE    ppbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppequiv;
 SET      soep.ppequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppequiv(label="SOEP.v29@school: ppequiv");
 MERGE    ppequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppfad;
 SET      soep.ppfad;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppfad(label="SOEP.v29@school: ppfad");
 MERGE    ppfad (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppgen;
 SET      soep.ppgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppgen(label="SOEP.v29@school: ppgen");
 MERGE    ppgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppkal;
 SET      soep.ppkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppkal(label="SOEP.v29@school: ppkal");
 MERGE    ppkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ppluecke;
 SET      soep.ppluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ppluecke(label="SOEP.v29@school: ppluecke");
 MERGE    ppluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     pwealth;
 SET      soep.pwealth;
 PROC SORT; BY hhnr;
RUN;
DATA      school.pwealth(label="SOEP.v29@school: pwealth");
 MERGE    pwealth (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qh;
 SET      soep.qh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qh(label="SOEP.v29@school: qh");
 MERGE    qh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qhbrutto;
 SET      soep.qhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qhbrutto(label="SOEP.v29@school: qhbrutto");
 MERGE    qhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qhgen;
 SET      soep.qhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qhgen(label="SOEP.v29@school: qhgen");
 MERGE    qhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qkind;
 SET      soep.qkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qkind(label="SOEP.v29@school: qkind");
 MERGE    qkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qp;
 SET      soep.qp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qp(label="SOEP.v29@school: qp");
 MERGE    qp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qpbrutto;
 SET      soep.qpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qpbrutto(label="SOEP.v29@school: qpbrutto");
 MERGE    qpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qpequiv;
 SET      soep.qpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qpequiv(label="SOEP.v29@school: qpequiv");
 MERGE    qpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qpgen;
 SET      soep.qpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qpgen(label="SOEP.v29@school: qpgen");
 MERGE    qpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qpkal;
 SET      soep.qpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qpkal(label="SOEP.v29@school: qpkal");
 MERGE    qpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     qpluecke;
 SET      soep.qpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.qpluecke(label="SOEP.v29@school: qpluecke");
 MERGE    qpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rh;
 SET      soep.rh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rh(label="SOEP.v29@school: rh");
 MERGE    rh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rhbrutto;
 SET      soep.rhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rhbrutto(label="SOEP.v29@school: rhbrutto");
 MERGE    rhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rhgen;
 SET      soep.rhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rhgen(label="SOEP.v29@school: rhgen");
 MERGE    rhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rkind;
 SET      soep.rkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rkind(label="SOEP.v29@school: rkind");
 MERGE    rkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rp;
 SET      soep.rp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rp(label="SOEP.v29@school: rp");
 MERGE    rp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rpbrutto;
 SET      soep.rpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rpbrutto(label="SOEP.v29@school: rpbrutto");
 MERGE    rpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rpequiv;
 SET      soep.rpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rpequiv(label="SOEP.v29@school: rpequiv");
 MERGE    rpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rpgen;
 SET      soep.rpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rpgen(label="SOEP.v29@school: rpgen");
 MERGE    rpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rpkal;
 SET      soep.rpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rpkal(label="SOEP.v29@school: rpkal");
 MERGE    rpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     rpluecke;
 SET      soep.rpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.rpluecke(label="SOEP.v29@school: rpluecke");
 MERGE    rpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     sh;
 SET      soep.sh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.sh(label="SOEP.v29@school: sh");
 MERGE    sh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     shbrutto;
 SET      soep.shbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.shbrutto(label="SOEP.v29@school: shbrutto");
 MERGE    shbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     shgen;
 SET      soep.shgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.shgen(label="SOEP.v29@school: shgen");
 MERGE    shgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     skind;
 SET      soep.skind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.skind(label="SOEP.v29@school: skind");
 MERGE    skind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     sozkalen;
 SET      soep.sozkalen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.sozkalen(label="SOEP.v29@school: sozkalen");
 MERGE    sozkalen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     sp;
 SET      soep.sp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.sp(label="SOEP.v29@school: sp");
 MERGE    sp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     spbrutto;
 SET      soep.spbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.spbrutto(label="SOEP.v29@school: spbrutto");
 MERGE    spbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     spequiv;
 SET      soep.spequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.spequiv(label="SOEP.v29@school: spequiv");
 MERGE    spequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     spgen;
 SET      soep.spgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.spgen(label="SOEP.v29@school: spgen");
 MERGE    spgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     spkal;
 SET      soep.spkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.spkal(label="SOEP.v29@school: spkal");
 MERGE    spkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     spluecke;
 SET      soep.spluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.spluecke(label="SOEP.v29@school: spluecke");
 MERGE    spluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     th;
 SET      soep.th;
 PROC SORT; BY hhnr;
RUN;
DATA      school.th(label="SOEP.v29@school: th");
 MERGE    th (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     thbrutto;
 SET      soep.thbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.thbrutto(label="SOEP.v29@school: thbrutto");
 MERGE    thbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     thgen;
 SET      soep.thgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.thgen(label="SOEP.v29@school: thgen");
 MERGE    thgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     timepref;
 SET      soep.timepref;
 PROC SORT; BY hhnr;
RUN;
DATA      school.timepref(label="SOEP.v29@school: timepref");
 MERGE    timepref (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tkind;
 SET      soep.tkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tkind(label="SOEP.v29@school: tkind");
 MERGE    tkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tp;
 SET      soep.tp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tp(label="SOEP.v29@school: tp");
 MERGE    tp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tpbrutto;
 SET      soep.tpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tpbrutto(label="SOEP.v29@school: tpbrutto");
 MERGE    tpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tpequiv;
 SET      soep.tpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tpequiv(label="SOEP.v29@school: tpequiv");
 MERGE    tpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tpgen;
 SET      soep.tpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tpgen(label="SOEP.v29@school: tpgen");
 MERGE    tpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tpkal;
 SET      soep.tpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tpkal(label="SOEP.v29@school: tpkal");
 MERGE    tpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     tpluecke;
 SET      soep.tpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.tpluecke(label="SOEP.v29@school: tpluecke");
 MERGE    tpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     trust;
 SET      soep.trust;
 PROC SORT; BY hhnr;
RUN;
DATA      school.trust(label="SOEP.v29@school: trust");
 MERGE    trust (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     uh;
 SET      soep.uh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.uh(label="SOEP.v29@school: uh");
 MERGE    uh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     uhbrutto;
 SET      soep.uhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.uhbrutto(label="SOEP.v29@school: uhbrutto");
 MERGE    uhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     uhgen;
 SET      soep.uhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.uhgen(label="SOEP.v29@school: uhgen");
 MERGE    uhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ukind;
 SET      soep.ukind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ukind(label="SOEP.v29@school: ukind");
 MERGE    ukind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     up;
 SET      soep.up;
 PROC SORT; BY hhnr;
RUN;
DATA      school.up(label="SOEP.v29@school: up");
 MERGE    up (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     upbrutto;
 SET      soep.upbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.upbrutto(label="SOEP.v29@school: upbrutto");
 MERGE    upbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     upequiv;
 SET      soep.upequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.upequiv(label="SOEP.v29@school: upequiv");
 MERGE    upequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     upgen;
 SET      soep.upgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.upgen(label="SOEP.v29@school: upgen");
 MERGE    upgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     upkal;
 SET      soep.upkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.upkal(label="SOEP.v29@school: upkal");
 MERGE    upkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     upluecke;
 SET      soep.upluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.upluecke(label="SOEP.v29@school: upluecke");
 MERGE    upluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vh;
 SET      soep.vh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vh(label="SOEP.v29@school: vh");
 MERGE    vh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vhbrutto;
 SET      soep.vhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vhbrutto(label="SOEP.v29@school: vhbrutto");
 MERGE    vhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vhgen;
 SET      soep.vhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vhgen(label="SOEP.v29@school: vhgen");
 MERGE    vhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vkind;
 SET      soep.vkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vkind(label="SOEP.v29@school: vkind");
 MERGE    vkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vp;
 SET      soep.vp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vp(label="SOEP.v29@school: vp");
 MERGE    vp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vpbrutto;
 SET      soep.vpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vpbrutto(label="SOEP.v29@school: vpbrutto");
 MERGE    vpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vpequiv;
 SET      soep.vpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vpequiv(label="SOEP.v29@school: vpequiv");
 MERGE    vpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vpgen;
 SET      soep.vpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vpgen(label="SOEP.v29@school: vpgen");
 MERGE    vpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vpkal;
 SET      soep.vpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vpkal(label="SOEP.v29@school: vpkal");
 MERGE    vpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     vpluecke;
 SET      soep.vpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.vpluecke(label="SOEP.v29@school: vpluecke");
 MERGE    vpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wh;
 SET      soep.wh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wh(label="SOEP.v29@school: wh");
 MERGE    wh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     whbrutto;
 SET      soep.whbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.whbrutto(label="SOEP.v29@school: whbrutto");
 MERGE    whbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     whgen;
 SET      soep.whgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.whgen(label="SOEP.v29@school: whgen");
 MERGE    whgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wkind;
 SET      soep.wkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wkind(label="SOEP.v29@school: wkind");
 MERGE    wkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wp;
 SET      soep.wp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wp(label="SOEP.v29@school: wp");
 MERGE    wp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpage17;
 SET      soep.wpage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpage17(label="SOEP.v29@school: wpage17");
 MERGE    wpage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpbrutto;
 SET      soep.wpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpbrutto(label="SOEP.v29@school: wpbrutto");
 MERGE    wpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpequiv;
 SET      soep.wpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpequiv(label="SOEP.v29@school: wpequiv");
 MERGE    wpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpgen;
 SET      soep.wpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpgen(label="SOEP.v29@school: wpgen");
 MERGE    wpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpkal;
 SET      soep.wpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpkal(label="SOEP.v29@school: wpkal");
 MERGE    wpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     wpluecke;
 SET      soep.wpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.wpluecke(label="SOEP.v29@school: wpluecke");
 MERGE    wpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xh;
 SET      soep.xh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xh(label="SOEP.v29@school: xh");
 MERGE    xh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xhbrutto;
 SET      soep.xhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xhbrutto(label="SOEP.v29@school: xhbrutto");
 MERGE    xhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xhgen;
 SET      soep.xhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xhgen(label="SOEP.v29@school: xhgen");
 MERGE    xhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xkind;
 SET      soep.xkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xkind(label="SOEP.v29@school: xkind");
 MERGE    xkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xp;
 SET      soep.xp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xp(label="SOEP.v29@school: xp");
 MERGE    xp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpage17;
 SET      soep.xpage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpage17(label="SOEP.v29@school: xpage17");
 MERGE    xpage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpbrutto;
 SET      soep.xpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpbrutto(label="SOEP.v29@school: xpbrutto");
 MERGE    xpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpequiv;
 SET      soep.xpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpequiv(label="SOEP.v29@school: xpequiv");
 MERGE    xpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpgen;
 SET      soep.xpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpgen(label="SOEP.v29@school: xpgen");
 MERGE    xpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpkal;
 SET      soep.xpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpkal(label="SOEP.v29@school: xpkal");
 MERGE    xpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     xpluecke;
 SET      soep.xpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.xpluecke(label="SOEP.v29@school: xpluecke");
 MERGE    xpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     yh;
 SET      soep.yh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.yh(label="SOEP.v29@school: yh");
 MERGE    yh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     yhbrutto;
 SET      soep.yhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.yhbrutto(label="SOEP.v29@school: yhbrutto");
 MERGE    yhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     yhgen;
 SET      soep.yhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.yhgen(label="SOEP.v29@school: yhgen");
 MERGE    yhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ykind;
 SET      soep.ykind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ykind(label="SOEP.v29@school: ykind");
 MERGE    ykind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     yp;
 SET      soep.yp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.yp(label="SOEP.v29@school: yp");
 MERGE    yp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypage17;
 SET      soep.ypage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypage17(label="SOEP.v29@school: ypage17");
 MERGE    ypage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypbrutto;
 SET      soep.ypbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypbrutto(label="SOEP.v29@school: ypbrutto");
 MERGE    ypbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypequiv;
 SET      soep.ypequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypequiv(label="SOEP.v29@school: ypequiv");
 MERGE    ypequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypgen;
 SET      soep.ypgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypgen(label="SOEP.v29@school: ypgen");
 MERGE    ypgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypkal;
 SET      soep.ypkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypkal(label="SOEP.v29@school: ypkal");
 MERGE    ypkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     ypluecke;
 SET      soep.ypluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.ypluecke(label="SOEP.v29@school: ypluecke");
 MERGE    ypluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zh;
 SET      soep.zh;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zh(label="SOEP.v29@school: zh");
 MERGE    zh (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zhbrutto;
 SET      soep.zhbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zhbrutto(label="SOEP.v29@school: zhbrutto");
 MERGE    zhbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zhgen;
 SET      soep.zhgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zhgen(label="SOEP.v29@school: zhgen");
 MERGE    zhgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zkind;
 SET      soep.zkind;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zkind(label="SOEP.v29@school: zkind");
 MERGE    zkind (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zp;
 SET      soep.zp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zp(label="SOEP.v29@school: zp");
 MERGE    zp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpage17;
 SET      soep.zpage17;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpage17(label="SOEP.v29@school: zpage17");
 MERGE    zpage17 (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpbrutto;
 SET      soep.zpbrutto;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpbrutto(label="SOEP.v29@school: zpbrutto");
 MERGE    zpbrutto (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpequiv;
 SET      soep.zpequiv;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpequiv(label="SOEP.v29@school: zpequiv");
 MERGE    zpequiv (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpgen;
 SET      soep.zpgen;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpgen(label="SOEP.v29@school: zpgen");
 MERGE    zpgen (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpkal;
 SET      soep.zpkal;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpkal(label="SOEP.v29@school: zpkal");
 MERGE    zpkal (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zpluecke;
 SET      soep.zpluecke;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zpluecke(label="SOEP.v29@school: zpluecke");
 MERGE    zpluecke (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;

DATA     zvp;
 SET      soep.zvp;
 PROC SORT; BY hhnr;
RUN;
DATA      school.zvp(label="SOEP.v29@school: zvp");
 MERGE    zvp (in=present) cirdef;
 BY       hhnr;
 IF       present;
 IF       rgroup20>10;
 DROP     rgroup20 ksample;
RUN;
/* -------------------------------------- */;