mono_arch_get_restore_context (struct MonoTrampInfo * * info, gboolean aot)
{
  void * code.0;
  guint8 * code.1;
  guint8 * code.2;
  guint8 * code.3;
  guint8 * code.4;
  guint8 * code.5;
  unsigned char D.23666;
  guint8 * code.6;
  guint8 * code.7;
  guint8 * code.8;
  guint8 * code.9;
  guint8 * code.10;
  guint8 * code.11;
  guint8 * code.12;
  guint8 * code.13;
  guint8 * code.14;
  guint8 * code.15;
  unsigned char D.23681;
  guint8 * code.16;
  guint8 * code.17;
  guint8 * code.18;
  guint8 * code.19;
  guint8 * code.20;
  guint8 * code.21;
  guint8 * code.22;
  guint8 * code.23;
  unsigned char D.23692;
  guint8 * code.24;
  guint8 * code.25;
  unsigned char D.23695;
  guint8 * code.26;
  guint8 * code.27;
  unsigned char D.23698;
  guint8 * code.28;
  guint8 * code.29;
  unsigned char D.23701;
  guint8 * code.30;
  guint8 * code.31;
  guint8 * code.32;
  guint8 * code.33;
  guint8 * code.34;
  guint8 * code.35;
  guint8 * code.36;
  guint8 * code.37;
  guint8 * code.38;
  guint8 * code.39;
  guint8 * code.40;
  guint8 * code.41;
  guint8 * code.42;
  guint8 * code.43;
  guint8 * code.44;
  unsigned char D.23726;
  guint8 * code.45;
  guint8 * code.46;
  unsigned char D.23729;
  guint8 * code.47;
  guint8 * code.48;
  unsigned char D.23732;
  guint8 * code.49;
  guint8 * code.50;
  unsigned char D.23735;
  guint8 * code.51;
  guint8 * code.52;
  guint8 * code.53;
  guint8 * code.54;
  guint8 * code.55;
  guint8 * code.56;
  guint8 * code.57;
  guint8 * code.58;
  unsigned char D.23749;
  guint8 * code.59;
  guint8 * code.60;
  unsigned char D.23752;
  guint8 * code.61;
  guint8 * code.62;
  unsigned char D.23755;
  guint8 * code.63;
  guint8 * code.64;
  unsigned char D.23758;
  guint8 * code.65;
  guint8 * code.66;
  guint8 * code.67;
  guint8 * code.68;
  unsigned char D.23767;
  guint8 * code.69;
  guint8 * code.70;
  guint8 * code.71;
  guint8 * code.72;
  guint8 * code.73;
  guint8 * code.74;
  guint8 * code.75;
  guint8 * code.76;
  unsigned char D.23778;
  guint8 * code.77;
  guint8 * code.78;
  unsigned char D.23781;
  guint8 * code.79;
  guint8 * code.80;
  unsigned char D.23784;
  guint8 * code.81;
  guint8 * code.82;
  unsigned char D.23787;
  guint8 * code.83;
  guint8 * code.84;
  guint8 * code.85;
  guint8 * code.86;
  guint8 * code.87;
  guint8 * code.88;
  guint8 * code.89;
  guint8 * code.90;
  guint8 * code.91;
  guint8 * code.92;
  guint8 * code.93;
  guint8 * code.94;
  guint8 * code.95;
  guint8 * code.96;
  unsigned char D.23811;
  guint8 * code.97;
  guint8 * code.98;
  unsigned char D.23814;
  guint8 * code.99;
  guint8 * code.100;
  unsigned char D.23817;
  guint8 * code.101;
  guint8 * code.102;
  unsigned char D.23820;
  guint8 * code.103;
  guint8 * code.104;
  guint8 * code.105;
  guint8 * code.106;
  guint8 * code.107;
  guint8 * code.108;
  guint8 * code.109;
  guint8 * code.110;
  unsigned char D.23834;
  guint8 * code.111;
  guint8 * code.112;
  unsigned char D.23837;
  guint8 * code.113;
  guint8 * code.114;
  unsigned char D.23840;
  guint8 * code.115;
  guint8 * code.116;
  unsigned char D.23843;
  guint8 * code.117;
  guint8 * code.118;
  guint8 * code.119;
  guint8 * code.120;
  unsigned char D.23852;
  guint8 * code.121;
  guint8 * code.122;
  guint8 * code.123;
  guint8 * code.124;
  guint8 * code.125;
  guint8 * code.126;
  guint8 * code.127;
  guint8 * code.128;
  unsigned char D.23863;
  guint8 * code.129;
  guint8 * code.130;
  unsigned char D.23866;
  guint8 * code.131;
  guint8 * code.132;
  unsigned char D.23869;
  guint8 * code.133;
  guint8 * code.134;
  unsigned char D.23872;
  guint8 * code.135;
  guint8 * code.136;
  guint8 * code.137;
  guint8 * code.138;
  guint8 * code.139;
  guint8 * code.140;
  guint8 * code.141;
  guint8 * code.142;
  guint8 * code.143;
  guint8 * code.144;
  guint8 * code.145;
  guint8 * code.146;
  guint8 * code.147;
  guint8 * code.148;
  unsigned char D.23896;
  guint8 * code.149;
  guint8 * code.150;
  unsigned char D.23899;
  guint8 * code.151;
  guint8 * code.152;
  unsigned char D.23902;
  guint8 * code.153;
  guint8 * code.154;
  unsigned char D.23905;
  guint8 * code.155;
  guint8 * code.156;
  guint8 * code.157;
  guint8 * code.158;
  guint8 * code.159;
  guint8 * code.160;
  guint8 * code.161;
  guint8 * code.162;
  unsigned char D.23919;
  guint8 * code.163;
  guint8 * code.164;
  unsigned char D.23922;
  guint8 * code.165;
  guint8 * code.166;
  unsigned char D.23925;
  guint8 * code.167;
  guint8 * code.168;
  unsigned char D.23928;
  guint8 * code.169;
  guint8 * code.170;
  guint8 * code.171;
  guint8 * code.172;
  unsigned char D.23937;
  guint8 * code.173;
  guint8 * code.174;
  guint8 * code.175;
  guint8 * code.176;
  guint8 * code.177;
  guint8 * code.178;
  guint8 * code.179;
  guint8 * code.180;
  unsigned char D.23948;
  guint8 * code.181;
  guint8 * code.182;
  unsigned char D.23951;
  guint8 * code.183;
  guint8 * code.184;
  unsigned char D.23954;
  guint8 * code.185;
  guint8 * code.186;
  unsigned char D.23957;
  guint8 * code.187;
  guint8 * code.188;
  guint8 * code.189;
  guint8 * code.190;
  guint8 * code.191;
  guint8 * code.192;
  guint8 * code.193;
  guint8 * code.194;
  guint8 * code.195;
  guint8 * code.196;
  guint8 * code.197;
  guint8 * code.198;
  guint8 * code.199;
  guint8 * code.200;
  unsigned char D.23981;
  guint8 * code.201;
  guint8 * code.202;
  unsigned char D.23984;
  guint8 * code.203;
  guint8 * code.204;
  unsigned char D.23987;
  guint8 * code.205;
  guint8 * code.206;
  unsigned char D.23990;
  guint8 * code.207;
  guint8 * code.208;
  guint8 * code.209;
  guint8 * code.210;
  guint8 * code.211;
  guint8 * code.212;
  guint8 * code.213;
  guint8 * code.214;
  unsigned char D.24004;
  guint8 * code.215;
  guint8 * code.216;
  unsigned char D.24007;
  guint8 * code.217;
  guint8 * code.218;
  unsigned char D.24010;
  guint8 * code.219;
  guint8 * code.220;
  unsigned char D.24013;
  guint8 * code.221;
  guint8 * code.222;
  guint8 * code.223;
  guint8 * code.224;
  unsigned char D.24022;
  guint8 * code.225;
  guint8 * code.226;
  guint8 * code.227;
  guint8 * code.228;
  guint8 * code.229;
  guint8 * code.230;
  guint8 * code.231;
  guint8 * code.232;
  unsigned char D.24033;
  guint8 * code.233;
  guint8 * code.234;
  unsigned char D.24036;
  guint8 * code.235;
  guint8 * code.236;
  unsigned char D.24039;
  guint8 * code.237;
  guint8 * code.238;
  unsigned char D.24042;
  guint8 * code.239;
  guint8 * code.240;
  guint8 * code.241;
  guint8 * code.242;
  guint8 * code.243;
  guint8 * code.244;
  guint8 * code.245;
  guint8 * code.246;
  guint8 * code.247;
  guint8 * code.248;
  guint8 * code.249;
  guint8 * code.250;
  guint8 * code.251;
  guint8 * code.252;
  unsigned char D.24066;
  guint8 * code.253;
  guint8 * code.254;
  unsigned char D.24069;
  guint8 * code.255;
  guint8 * code.256;
  unsigned char D.24072;
  guint8 * code.257;
  guint8 * code.258;
  unsigned char D.24075;
  guint8 * code.259;
  guint8 * code.260;
  guint8 * code.261;
  guint8 * code.262;
  guint8 * code.263;
  guint8 * code.264;
  guint8 * code.265;
  guint8 * code.266;
  unsigned char D.24089;
  guint8 * code.267;
  guint8 * code.268;
  unsigned char D.24092;
  guint8 * code.269;
  guint8 * code.270;
  unsigned char D.24095;
  guint8 * code.271;
  guint8 * code.272;
  unsigned char D.24098;
  guint8 * code.273;
  guint8 * code.274;
  guint8 * code.275;
  guint8 * code.276;
  unsigned char D.24107;
  guint8 * code.277;
  guint8 * code.278;
  guint8 * code.279;
  guint8 * code.280;
  guint8 * code.281;
  guint8 * code.282;
  guint8 * code.283;
  guint8 * code.284;
  unsigned char D.24118;
  guint8 * code.285;
  guint8 * code.286;
  unsigned char D.24121;
  guint8 * code.287;
  guint8 * code.288;
  unsigned char D.24124;
  guint8 * code.289;
  guint8 * code.290;
  unsigned char D.24127;
  guint8 * code.291;
  guint8 * code.292;
  guint8 * code.293;
  guint8 * code.294;
  guint8 * code.295;
  guint8 * code.296;
  guint8 * code.297;
  guint8 * code.298;
  guint8 * code.299;
  guint8 * code.300;
  guint8 * code.301;
  guint8 * code.302;
  guint8 * code.303;
  guint8 * code.304;
  unsigned char D.24151;
  guint8 * code.305;
  guint8 * code.306;
  unsigned char D.24154;
  guint8 * code.307;
  guint8 * code.308;
  unsigned char D.24157;
  guint8 * code.309;
  guint8 * code.310;
  unsigned char D.24160;
  guint8 * code.311;
  guint8 * code.312;
  guint8 * code.313;
  guint8 * code.314;
  guint8 * code.315;
  guint8 * code.316;
  guint8 * code.317;
  guint8 * code.318;
  unsigned char D.24174;
  guint8 * code.319;
  guint8 * code.320;
  unsigned char D.24177;
  guint8 * code.321;
  guint8 * code.322;
  unsigned char D.24180;
  guint8 * code.323;
  guint8 * code.324;
  unsigned char D.24183;
  guint8 * code.325;
  guint8 * code.326;
  guint8 * code.327;
  guint8 * code.328;
  unsigned char D.24192;
  guint8 * code.329;
  guint8 * code.330;
  guint8 * code.331;
  guint8 * code.332;
  guint8 * code.333;
  guint8 * code.334;
  guint8 * code.335;
  guint8 * code.336;
  unsigned char D.24203;
  guint8 * code.337;
  guint8 * code.338;
  unsigned char D.24206;
  guint8 * code.339;
  guint8 * code.340;
  unsigned char D.24209;
  guint8 * code.341;
  guint8 * code.342;
  unsigned char D.24212;
  guint8 * code.343;
  guint8 * code.344;
  guint8 * code.345;
  guint8 * code.346;
  guint8 * code.347;
  guint8 * code.348;
  guint8 * code.349;
  guint8 * code.350;
  guint8 * code.351;
  guint8 * code.352;
  guint8 * code.353;
  guint8 * code.354;
  guint8 * code.355;
  guint8 * code.356;
  unsigned char D.24236;
  guint8 * code.357;
  guint8 * code.358;
  unsigned char D.24239;
  guint8 * code.359;
  guint8 * code.360;
  unsigned char D.24242;
  guint8 * code.361;
  guint8 * code.362;
  unsigned char D.24245;
  guint8 * code.363;
  guint8 * code.364;
  guint8 * code.365;
  guint8 * code.366;
  guint8 * code.367;
  guint8 * code.368;
  guint8 * code.369;
  guint8 * code.370;
  unsigned char D.24259;
  guint8 * code.371;
  guint8 * code.372;
  unsigned char D.24262;
  guint8 * code.373;
  guint8 * code.374;
  unsigned char D.24265;
  guint8 * code.375;
  guint8 * code.376;
  unsigned char D.24268;
  guint8 * code.377;
  guint8 * code.378;
  guint8 * code.379;
  guint8 * code.380;
  unsigned char D.24277;
  guint8 * code.381;
  guint8 * code.382;
  guint8 * code.383;
  guint8 * code.384;
  guint8 * code.385;
  guint8 * code.386;
  guint8 * code.387;
  guint8 * code.388;
  unsigned char D.24288;
  guint8 * code.389;
  guint8 * code.390;
  unsigned char D.24291;
  guint8 * code.391;
  guint8 * code.392;
  unsigned char D.24294;
  guint8 * code.393;
  guint8 * code.394;
  unsigned char D.24297;
  guint8 * code.395;
  guint8 * code.396;
  guint8 * code.397;
  guint8 * code.398;
  guint8 * code.399;
  guint8 * code.400;
  guint8 * code.401;
  guint8 * code.402;
  guint8 * code.403;
  guint8 * code.404;
  guint8 * code.405;
  guint8 * code.406;
  guint8 * code.407;
  guint8 * code.408;
  unsigned char D.24321;
  guint8 * code.409;
  guint8 * code.410;
  unsigned char D.24324;
  guint8 * code.411;
  guint8 * code.412;
  unsigned char D.24327;
  guint8 * code.413;
  guint8 * code.414;
  unsigned char D.24330;
  guint8 * code.415;
  guint8 * code.416;
  guint8 * code.417;
  guint8 * code.418;
  guint8 * code.419;
  guint8 * code.420;
  guint8 * code.421;
  guint8 * code.422;
  unsigned char D.24344;
  guint8 * code.423;
  guint8 * code.424;
  unsigned char D.24347;
  guint8 * code.425;
  guint8 * code.426;
  unsigned char D.24350;
  guint8 * code.427;
  guint8 * code.428;
  unsigned char D.24353;
  guint8 * code.429;
  guint8 * code.430;
  guint8 * code.431;
  guint8 * code.432;
  unsigned char D.24362;
  guint8 * code.433;
  guint8 * code.434;
  guint8 * code.435;
  guint8 * code.436;
  guint8 * code.437;
  guint8 * code.438;
  guint8 * code.439;
  guint8 * code.440;
  unsigned char D.24373;
  guint8 * code.441;
  guint8 * code.442;
  unsigned char D.24376;
  guint8 * code.443;
  guint8 * code.444;
  unsigned char D.24379;
  guint8 * code.445;
  guint8 * code.446;
  unsigned char D.24382;
  guint8 * code.447;
  guint8 * code.448;
  guint8 * code.449;
  guint8 * code.450;
  guint8 * code.451;
  guint8 * code.452;
  guint8 * code.453;
  guint8 * code.454;
  guint8 * code.455;
  guint8 * code.456;
  guint8 * code.457;
  guint8 * code.458;
  guint8 * code.459;
  guint8 * code.460;
  unsigned char D.24406;
  guint8 * code.461;
  guint8 * code.462;
  unsigned char D.24409;
  guint8 * code.463;
  guint8 * code.464;
  unsigned char D.24412;
  guint8 * code.465;
  guint8 * code.466;
  unsigned char D.24415;
  guint8 * code.467;
  guint8 * code.468;
  guint8 * code.469;
  guint8 * code.470;
  guint8 * code.471;
  guint8 * code.472;
  guint8 * code.473;
  guint8 * code.474;
  unsigned char D.24429;
  guint8 * code.475;
  guint8 * code.476;
  unsigned char D.24432;
  guint8 * code.477;
  guint8 * code.478;
  unsigned char D.24435;
  guint8 * code.479;
  guint8 * code.480;
  unsigned char D.24438;
  guint8 * code.481;
  guint8 * code.482;
  guint8 * code.483;
  guint8 * code.484;
  unsigned char D.24447;
  guint8 * code.485;
  guint8 * code.486;
  guint8 * code.487;
  guint8 * code.488;
  guint8 * code.489;
  guint8 * code.490;
  guint8 * code.491;
  guint8 * code.492;
  unsigned char D.24458;
  guint8 * code.493;
  guint8 * code.494;
  unsigned char D.24461;
  guint8 * code.495;
  guint8 * code.496;
  unsigned char D.24464;
  guint8 * code.497;
  guint8 * code.498;
  unsigned char D.24467;
  guint8 * code.499;
  guint8 * code.500;
  guint8 * code.501;
  guint8 * code.502;
  guint8 * code.503;
  guint8 * code.504;
  guint8 * code.505;
  guint8 * code.506;
  guint8 * code.507;
  guint8 * code.508;
  guint8 * code.509;
  guint8 * code.510;
  guint8 * code.511;
  guint8 * code.512;
  unsigned char D.24491;
  guint8 * code.513;
  guint8 * code.514;
  unsigned char D.24494;
  guint8 * code.515;
  guint8 * code.516;
  unsigned char D.24497;
  guint8 * code.517;
  guint8 * code.518;
  unsigned char D.24500;
  guint8 * code.519;
  guint8 * code.520;
  guint8 * code.521;
  guint8 * code.522;
  guint8 * code.523;
  guint8 * code.524;
  guint8 * code.525;
  guint8 * code.526;
  unsigned char D.24514;
  guint8 * code.527;
  guint8 * code.528;
  unsigned char D.24517;
  guint8 * code.529;
  guint8 * code.530;
  unsigned char D.24520;
  guint8 * code.531;
  guint8 * code.532;
  unsigned char D.24523;
  guint8 * code.533;
  guint8 * code.534;
  guint8 * code.535;
  guint8 * code.536;
  unsigned char D.24532;
  guint8 * code.537;
  guint8 * code.538;
  guint8 * code.539;
  guint8 * code.540;
  guint8 * code.541;
  guint8 * code.542;
  guint8 * code.543;
  guint8 * code.544;
  unsigned char D.24543;
  guint8 * code.545;
  guint8 * code.546;
  unsigned char D.24546;
  guint8 * code.547;
  guint8 * code.548;
  unsigned char D.24549;
  guint8 * code.549;
  guint8 * code.550;
  unsigned char D.24552;
  guint8 * code.551;
  guint8 * code.552;
  guint8 * code.553;
  guint8 * code.554;
  guint8 * code.555;
  guint8 * code.556;
  guint8 * code.557;
  guint8 * code.558;
  guint8 * code.559;
  guint8 * code.560;
  guint8 * code.561;
  guint8 * code.562;
  guint8 * code.563;
  guint8 * code.564;
  unsigned char D.24576;
  guint8 * code.565;
  guint8 * code.566;
  unsigned char D.24579;
  guint8 * code.567;
  guint8 * code.568;
  unsigned char D.24582;
  guint8 * code.569;
  guint8 * code.570;
  unsigned char D.24585;
  guint8 * code.571;
  guint8 * code.572;
  guint8 * code.573;
  guint8 * code.574;
  guint8 * code.575;
  guint8 * code.576;
  guint8 * code.577;
  guint8 * code.578;
  unsigned char D.24599;
  guint8 * code.579;
  guint8 * code.580;
  unsigned char D.24602;
  guint8 * code.581;
  guint8 * code.582;
  unsigned char D.24605;
  guint8 * code.583;
  guint8 * code.584;
  unsigned char D.24608;
  guint8 * code.585;
  guint8 * code.586;
  guint8 * code.587;
  guint8 * code.588;
  unsigned char D.24617;
  guint8 * code.589;
  guint8 * code.590;
  guint8 * code.591;
  guint8 * code.592;
  guint8 * code.593;
  guint8 * code.594;
  guint8 * code.595;
  guint8 * code.596;
  unsigned char D.24628;
  guint8 * code.597;
  guint8 * code.598;
  unsigned char D.24631;
  guint8 * code.599;
  guint8 * code.600;
  unsigned char D.24634;
  guint8 * code.601;
  guint8 * code.602;
  unsigned char D.24637;
  guint8 * code.603;
  guint8 * code.604;
  guint8 * code.605;
  guint8 * code.606;
  guint8 * code.607;
  guint8 * code.608;
  guint8 * code.609;
  guint8 * code.610;
  guint8 * code.611;
  guint8 * code.612;
  guint8 * code.613;
  guint8 * code.614;
  guint8 * code.615;
  guint8 * code.616;
  unsigned char D.24661;
  guint8 * code.617;
  guint8 * code.618;
  unsigned char D.24664;
  guint8 * code.619;
  guint8 * code.620;
  unsigned char D.24667;
  guint8 * code.621;
  guint8 * code.622;
  unsigned char D.24670;
  guint8 * code.623;
  guint8 * code.624;
  guint8 * code.625;
  guint8 * code.626;
  guint8 * code.627;
  guint8 * code.628;
  guint8 * code.629;
  guint8 * code.630;
  unsigned char D.24684;
  guint8 * code.631;
  guint8 * code.632;
  unsigned char D.24687;
  guint8 * code.633;
  guint8 * code.634;
  unsigned char D.24690;
  guint8 * code.635;
  guint8 * code.636;
  unsigned char D.24693;
  guint8 * code.637;
  guint8 * code.638;
  guint8 * code.639;
  guint8 * code.640;
  unsigned char D.24702;
  guint8 * code.641;
  guint8 * code.642;
  guint8 * code.643;
  guint8 * code.644;
  guint8 * code.645;
  guint8 * code.646;
  guint8 * code.647;
  guint8 * code.648;
  unsigned char D.24713;
  guint8 * code.649;
  guint8 * code.650;
  unsigned char D.24716;
  guint8 * code.651;
  guint8 * code.652;
  unsigned char D.24719;
  guint8 * code.653;
  guint8 * code.654;
  unsigned char D.24722;
  guint8 * code.655;
  guint8 * code.656;
  guint8 * code.657;
  guint8 * code.658;
  guint8 * code.659;
  guint8 * code.660;
  guint8 * code.661;
  guint8 * code.662;
  guint8 * code.663;
  guint8 * code.664;
  guint8 * code.665;
  guint8 * code.666;
  guint8 * code.667;
  guint8 * code.668;
  unsigned char D.24746;
  guint8 * code.669;
  guint8 * code.670;
  unsigned char D.24749;
  guint8 * code.671;
  guint8 * code.672;
  unsigned char D.24752;
  guint8 * code.673;
  guint8 * code.674;
  unsigned char D.24755;
  guint8 * code.675;
  guint8 * code.676;
  guint8 * code.677;
  guint8 * code.678;
  guint8 * code.679;
  guint8 * code.680;
  guint8 * code.681;
  guint8 * code.682;
  unsigned char D.24769;
  guint8 * code.683;
  guint8 * code.684;
  unsigned char D.24772;
  guint8 * code.685;
  guint8 * code.686;
  unsigned char D.24775;
  guint8 * code.687;
  guint8 * code.688;
  unsigned char D.24778;
  guint8 * code.689;
  guint8 * code.690;
  guint8 * code.691;
  guint8 * code.692;
  unsigned char D.24787;
  guint8 * code.693;
  guint8 * code.694;
  guint8 * code.695;
  guint8 * code.696;
  guint8 * code.697;
  guint8 * code.698;
  guint8 * code.699;
  guint8 * code.700;
  unsigned char D.24798;
  guint8 * code.701;
  guint8 * code.702;
  guint8 * code.703;
  guint8 * code.704;
  long int code.705;
  guint8 * start.706;
  long int start.707;
  long int D.24806;
  int D.24807;
  unsigned int D.24810;
  struct MonoTrampInfo * D.24811;
  void * D.24812;
  guint8 * start;
  guint8 * code;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  static const char __PRETTY_FUNCTION__[30] = "mono_arch_get_restore_context";

  try
    {
      start = 0B;
      ji = 0B;
      unwind_ops = 0B;
      code.0 = mono_global_codeman_reserve (256);
      code = code.0;
      code.1 = code;
      start = code.1;
      if (0 != 0) goto <D.23658>; else goto <D.23659>;
      <D.23658>:
      code.1 = code;
      code.2 = code.1;
      code.3 = code.2 + 1;
      code = code.3;
      *code.2 = 102;
      <D.23659>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.23662>; else goto <D.23663>;
        <D.23662>:
        code.1 = code;
        code.4 = code.1;
        code.5 = code.4 + 1;
        code = code.5;
        D.23666 = _amd64_rex_bits | 64;
        *code.4 = D.23666;
        <D.23663>:
      }
      switch (8) <default: <D.22776>, case 1: <D.22771>, case 2: <D.22773>, case 4: <D.22774>, case 8: <D.22775>>
      <D.22771>:
      code.1 = code;
      code.6 = code.1;
      code.7 = code.6 + 1;
      code = code.7;
      *code.6 = 138;
      goto <D.22772>;
      <D.22773>:
      <D.22774>:
      <D.22775>:
      code.1 = code;
      code.8 = code.1;
      code.9 = code.8 + 1;
      code = code.9;
      *code.8 = 139;
      goto <D.22772>;
      <D.22776>:
      __assert_fail ("0", "exceptions-amd64.c", 207, &__PRETTY_FUNCTION__);
      <D.22772>:
      code.1 = code;
      code.10 = code.1;
      code.11 = code.10 + 1;
      code = code.11;
      *code.10 = 223;
      if (0 != 0) goto <D.23673>; else goto <D.23674>;
      <D.23673>:
      code.1 = code;
      code.12 = code.1;
      code.13 = code.12 + 1;
      code = code.13;
      *code.12 = 102;
      <D.23674>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.23677>; else goto <D.23678>;
        <D.23677>:
        code.1 = code;
        code.14 = code.1;
        code.15 = code.14 + 1;
        code = code.15;
        D.23681 = _amd64_rex_bits | 64;
        *code.14 = D.23681;
        <D.23678>:
      }
      switch (8) <default: <D.22784>, case 1: <D.22779>, case 2: <D.22781>, case 4: <D.22782>, case 8: <D.22783>>
      <D.22779>:
      code.1 = code;
      code.16 = code.1;
      code.17 = code.16 + 1;
      code = code.17;
      *code.16 = 138;
      goto <D.22780>;
      <D.22781>:
      <D.22782>:
      <D.22783>:
      code.1 = code;
      code.18 = code.1;
      code.19 = code.18 + 1;
      code = code.19;
      *code.18 = 139;
      goto <D.22780>;
      <D.22784>:
      __assert_fail ("0", "exceptions-amd64.c", 210, &__PRETTY_FUNCTION__);
      <D.22780>:
      if (0 != 0) goto <D.23686>; else goto <D.23687>;
      <D.23686>:
      code.1 = code;
      code.20 = code.1;
      code.21 = code.20 + 1;
      code = code.21;
      *code.20 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1 = code;
            code.22 = code.1;
            code.23 = code.22 + 1;
            code = code.23;
            D.23692 = imb.b[0];
            *code.22 = D.23692;
            code.1 = code;
            code.24 = code.1;
            code.25 = code.24 + 1;
            code = code.25;
            D.23695 = imb.b[1];
            *code.24 = D.23695;
            code.1 = code;
            code.26 = code.1;
            code.27 = code.26 + 1;
            code = code.27;
            D.23698 = imb.b[2];
            *code.26 = D.23698;
            code.1 = code;
            code.28 = code.1;
            code.29 = code.28 + 1;
            code = code.29;
            D.23701 = imb.b[3];
            *code.28 = D.23701;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23702>;
      <D.23687>:
      if (0 != 0) goto <D.23703>; else goto <D.23704>;
      <D.23703>:
      if (1 != 0) goto <D.23705>; else goto <D.23706>;
      <D.23705>:
      code.1 = code;
      code.30 = code.1;
      code.31 = code.30 + 1;
      code = code.31;
      *code.30 = 4;
      code.1 = code;
      code.32 = code.1;
      code.33 = code.32 + 1;
      code = code.33;
      *code.32 = 36;
      goto <D.23711>;
      <D.23706>:
      if (1 != 0) goto <D.23712>; else goto <D.23713>;
      <D.23712>:
      code.1 = code;
      code.34 = code.1;
      code.35 = code.34 + 1;
      code = code.35;
      *code.34 = 68;
      code.1 = code;
      code.36 = code.1;
      code.37 = code.36 + 1;
      code = code.37;
      *code.36 = 36;
      code.1 = code;
      *code.1 = 0;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23719>;
      <D.23713>:
      code.1 = code;
      code.39 = code.1;
      code.40 = code.39 + 1;
      code = code.40;
      *code.39 = 132;
      code.1 = code;
      code.41 = code.1;
      code.42 = code.41 + 1;
      code = code.42;
      *code.41 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1 = code;
            code.43 = code.1;
            code.44 = code.43 + 1;
            code = code.44;
            D.23726 = imb.b[0];
            *code.43 = D.23726;
            code.1 = code;
            code.45 = code.1;
            code.46 = code.45 + 1;
            code = code.46;
            D.23729 = imb.b[1];
            *code.45 = D.23729;
            code.1 = code;
            code.47 = code.1;
            code.48 = code.47 + 1;
            code = code.48;
            D.23732 = imb.b[2];
            *code.47 = D.23732;
            code.1 = code;
            code.49 = code.1;
            code.50 = code.49 + 1;
            code = code.50;
            D.23735 = imb.b[3];
            *code.49 = D.23735;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23719>:
      <D.23711>:
      goto <D.22787>;
      <D.23704>:
      if (1 != 0) goto <D.23736>; else goto <D.23737>;
      <D.23736>:
      code.1 = code;
      code.51 = code.1;
      code.52 = code.51 + 1;
      code = code.52;
      *code.51 = 3;
      goto <D.22787>;
      <D.23737>:
      if (1 != 0) goto <D.23740>; else goto <D.23741>;
      <D.23740>:
      code.1 = code;
      code.53 = code.1;
      code.54 = code.53 + 1;
      code = code.54;
      *code.53 = 67;
      code.1 = code;
      *code.1 = 0;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23744>;
      <D.23741>:
      code.1 = code;
      code.55 = code.1;
      code.56 = code.55 + 1;
      code = code.56;
      *code.55 = 131;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1 = code;
            code.57 = code.1;
            code.58 = code.57 + 1;
            code = code.58;
            D.23749 = imb.b[0];
            *code.57 = D.23749;
            code.1 = code;
            code.59 = code.1;
            code.60 = code.59 + 1;
            code = code.60;
            D.23752 = imb.b[1];
            *code.59 = D.23752;
            code.1 = code;
            code.61 = code.1;
            code.62 = code.61 + 1;
            code = code.62;
            D.23755 = imb.b[2];
            *code.61 = D.23755;
            code.1 = code;
            code.63 = code.1;
            code.64 = code.63 + 1;
            code = code.64;
            D.23758 = imb.b[3];
            *code.63 = D.23758;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23744>:
      <D.22787>:
      <D.23702>:
      if (0 != 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      code.1 = code;
      code.65 = code.1;
      code.66 = code.65 + 1;
      code = code.66;
      *code.65 = 102;
      <D.23760>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.23763>; else goto <D.23764>;
        <D.23763>:
        code.1 = code;
        code.67 = code.1;
        code.68 = code.67 + 1;
        code = code.68;
        D.23767 = _amd64_rex_bits | 64;
        *code.67 = D.23767;
        <D.23764>:
      }
      switch (8) <default: <D.22795>, case 1: <D.22790>, case 2: <D.22792>, case 4: <D.22793>, case 8: <D.22794>>
      <D.22790>:
      code.1 = code;
      code.69 = code.1;
      code.70 = code.69 + 1;
      code = code.70;
      *code.69 = 138;
      goto <D.22791>;
      <D.22792>:
      <D.22793>:
      <D.22794>:
      code.1 = code;
      code.71 = code.1;
      code.72 = code.71 + 1;
      code = code.72;
      *code.71 = 139;
      goto <D.22791>;
      <D.22795>:
      __assert_fail ("0", "exceptions-amd64.c", 211, &__PRETTY_FUNCTION__);
      <D.22791>:
      if (0 != 0) goto <D.23772>; else goto <D.23773>;
      <D.23772>:
      code.1 = code;
      code.73 = code.1;
      code.74 = code.73 + 1;
      code = code.74;
      *code.73 = 13;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.1 = code;
            code.75 = code.1;
            code.76 = code.75 + 1;
            code = code.76;
            D.23778 = imb.b[0];
            *code.75 = D.23778;
            code.1 = code;
            code.77 = code.1;
            code.78 = code.77 + 1;
            code = code.78;
            D.23781 = imb.b[1];
            *code.77 = D.23781;
            code.1 = code;
            code.79 = code.1;
            code.80 = code.79 + 1;
            code = code.80;
            D.23784 = imb.b[2];
            *code.79 = D.23784;
            code.1 = code;
            code.81 = code.1;
            code.82 = code.81 + 1;
            code = code.82;
            D.23787 = imb.b[3];
            *code.81 = D.23787;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23788>;
      <D.23773>:
      if (0 != 0) goto <D.23789>; else goto <D.23790>;
      <D.23789>:
      if (0 != 0) goto <D.23791>; else goto <D.23792>;
      <D.23791>:
      code.1 = code;
      code.83 = code.1;
      code.84 = code.83 + 1;
      code = code.84;
      *code.83 = 12;
      code.1 = code;
      code.85 = code.1;
      code.86 = code.85 + 1;
      code = code.86;
      *code.85 = 36;
      goto <D.23797>;
      <D.23792>:
      if (1 != 0) goto <D.23798>; else goto <D.23799>;
      <D.23798>:
      code.1 = code;
      code.87 = code.1;
      code.88 = code.87 + 1;
      code = code.88;
      *code.87 = 76;
      code.1 = code;
      code.89 = code.1;
      code.90 = code.89 + 1;
      code = code.90;
      *code.89 = 36;
      code.1 = code;
      *code.1 = 16;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23804>;
      <D.23799>:
      code.1 = code;
      code.91 = code.1;
      code.92 = code.91 + 1;
      code = code.92;
      *code.91 = 140;
      code.1 = code;
      code.93 = code.1;
      code.94 = code.93 + 1;
      code = code.94;
      *code.93 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.1 = code;
            code.95 = code.1;
            code.96 = code.95 + 1;
            code = code.96;
            D.23811 = imb.b[0];
            *code.95 = D.23811;
            code.1 = code;
            code.97 = code.1;
            code.98 = code.97 + 1;
            code = code.98;
            D.23814 = imb.b[1];
            *code.97 = D.23814;
            code.1 = code;
            code.99 = code.1;
            code.100 = code.99 + 1;
            code = code.100;
            D.23817 = imb.b[2];
            *code.99 = D.23817;
            code.1 = code;
            code.101 = code.1;
            code.102 = code.101 + 1;
            code = code.102;
            D.23820 = imb.b[3];
            *code.101 = D.23820;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23804>:
      <D.23797>:
      goto <D.22798>;
      <D.23790>:
      if (0 != 0) goto <D.23821>; else goto <D.23822>;
      <D.23821>:
      code.1 = code;
      code.103 = code.1;
      code.104 = code.103 + 1;
      code = code.104;
      *code.103 = 11;
      goto <D.22798>;
      <D.23822>:
      if (1 != 0) goto <D.23825>; else goto <D.23826>;
      <D.23825>:
      code.1 = code;
      code.105 = code.1;
      code.106 = code.105 + 1;
      code = code.106;
      *code.105 = 75;
      code.1 = code;
      *code.1 = 16;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23829>;
      <D.23826>:
      code.1 = code;
      code.107 = code.1;
      code.108 = code.107 + 1;
      code = code.108;
      *code.107 = 139;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.1 = code;
            code.109 = code.1;
            code.110 = code.109 + 1;
            code = code.110;
            D.23834 = imb.b[0];
            *code.109 = D.23834;
            code.1 = code;
            code.111 = code.1;
            code.112 = code.111 + 1;
            code = code.112;
            D.23837 = imb.b[1];
            *code.111 = D.23837;
            code.1 = code;
            code.113 = code.1;
            code.114 = code.113 + 1;
            code = code.114;
            D.23840 = imb.b[2];
            *code.113 = D.23840;
            code.1 = code;
            code.115 = code.1;
            code.116 = code.115 + 1;
            code = code.116;
            D.23843 = imb.b[3];
            *code.115 = D.23843;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23829>:
      <D.22798>:
      <D.23788>:
      if (0 != 0) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      code.1 = code;
      code.117 = code.1;
      code.118 = code.117 + 1;
      code = code.118;
      *code.117 = 102;
      <D.23845>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.23848>; else goto <D.23849>;
        <D.23848>:
        code.1 = code;
        code.119 = code.1;
        code.120 = code.119 + 1;
        code = code.120;
        D.23852 = _amd64_rex_bits | 64;
        *code.119 = D.23852;
        <D.23849>:
      }
      switch (8) <default: <D.22806>, case 1: <D.22801>, case 2: <D.22803>, case 4: <D.22804>, case 8: <D.22805>>
      <D.22801>:
      code.1 = code;
      code.121 = code.1;
      code.122 = code.121 + 1;
      code = code.122;
      *code.121 = 138;
      goto <D.22802>;
      <D.22803>:
      <D.22804>:
      <D.22805>:
      code.1 = code;
      code.123 = code.1;
      code.124 = code.123 + 1;
      code = code.124;
      *code.123 = 139;
      goto <D.22802>;
      <D.22806>:
      __assert_fail ("0", "exceptions-amd64.c", 212, &__PRETTY_FUNCTION__);
      <D.22802>:
      if (0 != 0) goto <D.23857>; else goto <D.23858>;
      <D.23857>:
      code.1 = code;
      code.125 = code.1;
      code.126 = code.125 + 1;
      code = code.126;
      *code.125 = 21;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.1 = code;
            code.127 = code.1;
            code.128 = code.127 + 1;
            code = code.128;
            D.23863 = imb.b[0];
            *code.127 = D.23863;
            code.1 = code;
            code.129 = code.1;
            code.130 = code.129 + 1;
            code = code.130;
            D.23866 = imb.b[1];
            *code.129 = D.23866;
            code.1 = code;
            code.131 = code.1;
            code.132 = code.131 + 1;
            code = code.132;
            D.23869 = imb.b[2];
            *code.131 = D.23869;
            code.1 = code;
            code.133 = code.1;
            code.134 = code.133 + 1;
            code = code.134;
            D.23872 = imb.b[3];
            *code.133 = D.23872;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23873>;
      <D.23858>:
      if (0 != 0) goto <D.23874>; else goto <D.23875>;
      <D.23874>:
      if (0 != 0) goto <D.23876>; else goto <D.23877>;
      <D.23876>:
      code.1 = code;
      code.135 = code.1;
      code.136 = code.135 + 1;
      code = code.136;
      *code.135 = 20;
      code.1 = code;
      code.137 = code.1;
      code.138 = code.137 + 1;
      code = code.138;
      *code.137 = 36;
      goto <D.23882>;
      <D.23877>:
      if (1 != 0) goto <D.23883>; else goto <D.23884>;
      <D.23883>:
      code.1 = code;
      code.139 = code.1;
      code.140 = code.139 + 1;
      code = code.140;
      *code.139 = 84;
      code.1 = code;
      code.141 = code.1;
      code.142 = code.141 + 1;
      code = code.142;
      *code.141 = 36;
      code.1 = code;
      *code.1 = 24;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23889>;
      <D.23884>:
      code.1 = code;
      code.143 = code.1;
      code.144 = code.143 + 1;
      code = code.144;
      *code.143 = 148;
      code.1 = code;
      code.145 = code.1;
      code.146 = code.145 + 1;
      code = code.146;
      *code.145 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.1 = code;
            code.147 = code.1;
            code.148 = code.147 + 1;
            code = code.148;
            D.23896 = imb.b[0];
            *code.147 = D.23896;
            code.1 = code;
            code.149 = code.1;
            code.150 = code.149 + 1;
            code = code.150;
            D.23899 = imb.b[1];
            *code.149 = D.23899;
            code.1 = code;
            code.151 = code.1;
            code.152 = code.151 + 1;
            code = code.152;
            D.23902 = imb.b[2];
            *code.151 = D.23902;
            code.1 = code;
            code.153 = code.1;
            code.154 = code.153 + 1;
            code = code.154;
            D.23905 = imb.b[3];
            *code.153 = D.23905;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23889>:
      <D.23882>:
      goto <D.22809>;
      <D.23875>:
      if (0 != 0) goto <D.23906>; else goto <D.23907>;
      <D.23906>:
      code.1 = code;
      code.155 = code.1;
      code.156 = code.155 + 1;
      code = code.156;
      *code.155 = 19;
      goto <D.22809>;
      <D.23907>:
      if (1 != 0) goto <D.23910>; else goto <D.23911>;
      <D.23910>:
      code.1 = code;
      code.157 = code.1;
      code.158 = code.157 + 1;
      code = code.158;
      *code.157 = 83;
      code.1 = code;
      *code.1 = 24;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23914>;
      <D.23911>:
      code.1 = code;
      code.159 = code.1;
      code.160 = code.159 + 1;
      code = code.160;
      *code.159 = 147;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.1 = code;
            code.161 = code.1;
            code.162 = code.161 + 1;
            code = code.162;
            D.23919 = imb.b[0];
            *code.161 = D.23919;
            code.1 = code;
            code.163 = code.1;
            code.164 = code.163 + 1;
            code = code.164;
            D.23922 = imb.b[1];
            *code.163 = D.23922;
            code.1 = code;
            code.165 = code.1;
            code.166 = code.165 + 1;
            code = code.166;
            D.23925 = imb.b[2];
            *code.165 = D.23925;
            code.1 = code;
            code.167 = code.1;
            code.168 = code.167 + 1;
            code = code.168;
            D.23928 = imb.b[3];
            *code.167 = D.23928;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23914>:
      <D.22809>:
      <D.23873>:
      if (0 != 0) goto <D.23929>; else goto <D.23930>;
      <D.23929>:
      code.1 = code;
      code.169 = code.1;
      code.170 = code.169 + 1;
      code = code.170;
      *code.169 = 102;
      <D.23930>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.23933>; else goto <D.23934>;
        <D.23933>:
        code.1 = code;
        code.171 = code.1;
        code.172 = code.171 + 1;
        code = code.172;
        D.23937 = _amd64_rex_bits | 64;
        *code.171 = D.23937;
        <D.23934>:
      }
      switch (8) <default: <D.22817>, case 1: <D.22812>, case 2: <D.22814>, case 4: <D.22815>, case 8: <D.22816>>
      <D.22812>:
      code.1 = code;
      code.173 = code.1;
      code.174 = code.173 + 1;
      code = code.174;
      *code.173 = 138;
      goto <D.22813>;
      <D.22814>:
      <D.22815>:
      <D.22816>:
      code.1 = code;
      code.175 = code.1;
      code.176 = code.175 + 1;
      code = code.176;
      *code.175 = 139;
      goto <D.22813>;
      <D.22817>:
      __assert_fail ("0", "exceptions-amd64.c", 213, &__PRETTY_FUNCTION__);
      <D.22813>:
      if (0 != 0) goto <D.23942>; else goto <D.23943>;
      <D.23942>:
      code.1 = code;
      code.177 = code.1;
      code.178 = code.177 + 1;
      code = code.178;
      *code.177 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1 = code;
            code.179 = code.1;
            code.180 = code.179 + 1;
            code = code.180;
            D.23948 = imb.b[0];
            *code.179 = D.23948;
            code.1 = code;
            code.181 = code.1;
            code.182 = code.181 + 1;
            code = code.182;
            D.23951 = imb.b[1];
            *code.181 = D.23951;
            code.1 = code;
            code.183 = code.1;
            code.184 = code.183 + 1;
            code = code.184;
            D.23954 = imb.b[2];
            *code.183 = D.23954;
            code.1 = code;
            code.185 = code.1;
            code.186 = code.185 + 1;
            code = code.186;
            D.23957 = imb.b[3];
            *code.185 = D.23957;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.23958>;
      <D.23943>:
      if (0 != 0) goto <D.23959>; else goto <D.23960>;
      <D.23959>:
      if (0 != 0) goto <D.23961>; else goto <D.23962>;
      <D.23961>:
      code.1 = code;
      code.187 = code.1;
      code.188 = code.187 + 1;
      code = code.188;
      *code.187 = 28;
      code.1 = code;
      code.189 = code.1;
      code.190 = code.189 + 1;
      code = code.190;
      *code.189 = 36;
      goto <D.23967>;
      <D.23962>:
      if (1 != 0) goto <D.23968>; else goto <D.23969>;
      <D.23968>:
      code.1 = code;
      code.191 = code.1;
      code.192 = code.191 + 1;
      code = code.192;
      *code.191 = 92;
      code.1 = code;
      code.193 = code.1;
      code.194 = code.193 + 1;
      code = code.194;
      *code.193 = 36;
      code.1 = code;
      *code.1 = 8;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23974>;
      <D.23969>:
      code.1 = code;
      code.195 = code.1;
      code.196 = code.195 + 1;
      code = code.196;
      *code.195 = 156;
      code.1 = code;
      code.197 = code.1;
      code.198 = code.197 + 1;
      code = code.198;
      *code.197 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1 = code;
            code.199 = code.1;
            code.200 = code.199 + 1;
            code = code.200;
            D.23981 = imb.b[0];
            *code.199 = D.23981;
            code.1 = code;
            code.201 = code.1;
            code.202 = code.201 + 1;
            code = code.202;
            D.23984 = imb.b[1];
            *code.201 = D.23984;
            code.1 = code;
            code.203 = code.1;
            code.204 = code.203 + 1;
            code = code.204;
            D.23987 = imb.b[2];
            *code.203 = D.23987;
            code.1 = code;
            code.205 = code.1;
            code.206 = code.205 + 1;
            code = code.206;
            D.23990 = imb.b[3];
            *code.205 = D.23990;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23974>:
      <D.23967>:
      goto <D.22820>;
      <D.23960>:
      if (0 != 0) goto <D.23991>; else goto <D.23992>;
      <D.23991>:
      code.1 = code;
      code.207 = code.1;
      code.208 = code.207 + 1;
      code = code.208;
      *code.207 = 27;
      goto <D.22820>;
      <D.23992>:
      if (1 != 0) goto <D.23995>; else goto <D.23996>;
      <D.23995>:
      code.1 = code;
      code.209 = code.1;
      code.210 = code.209 + 1;
      code = code.210;
      *code.209 = 91;
      code.1 = code;
      *code.1 = 8;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.23999>;
      <D.23996>:
      code.1 = code;
      code.211 = code.1;
      code.212 = code.211 + 1;
      code = code.212;
      *code.211 = 155;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.1 = code;
            code.213 = code.1;
            code.214 = code.213 + 1;
            code = code.214;
            D.24004 = imb.b[0];
            *code.213 = D.24004;
            code.1 = code;
            code.215 = code.1;
            code.216 = code.215 + 1;
            code = code.216;
            D.24007 = imb.b[1];
            *code.215 = D.24007;
            code.1 = code;
            code.217 = code.1;
            code.218 = code.217 + 1;
            code = code.218;
            D.24010 = imb.b[2];
            *code.217 = D.24010;
            code.1 = code;
            code.219 = code.1;
            code.220 = code.219 + 1;
            code = code.220;
            D.24013 = imb.b[3];
            *code.219 = D.24013;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.23999>:
      <D.22820>:
      <D.23958>:
      if (0 != 0) goto <D.24014>; else goto <D.24015>;
      <D.24014>:
      code.1 = code;
      code.221 = code.1;
      code.222 = code.221 + 1;
      code = code.222;
      *code.221 = 102;
      <D.24015>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.24018>; else goto <D.24019>;
        <D.24018>:
        code.1 = code;
        code.223 = code.1;
        code.224 = code.223 + 1;
        code = code.224;
        D.24022 = _amd64_rex_bits | 64;
        *code.223 = D.24022;
        <D.24019>:
      }
      switch (8) <default: <D.22828>, case 1: <D.22823>, case 2: <D.22825>, case 4: <D.22826>, case 8: <D.22827>>
      <D.22823>:
      code.1 = code;
      code.225 = code.1;
      code.226 = code.225 + 1;
      code = code.226;
      *code.225 = 138;
      goto <D.22824>;
      <D.22825>:
      <D.22826>:
      <D.22827>:
      code.1 = code;
      code.227 = code.1;
      code.228 = code.227 + 1;
      code = code.228;
      *code.227 = 139;
      goto <D.22824>;
      <D.22828>:
      __assert_fail ("0", "exceptions-amd64.c", 214, &__PRETTY_FUNCTION__);
      <D.22824>:
      if (0 != 0) goto <D.24027>; else goto <D.24028>;
      <D.24027>:
      code.1 = code;
      code.229 = code.1;
      code.230 = code.229 + 1;
      code = code.230;
      *code.229 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.1 = code;
            code.231 = code.1;
            code.232 = code.231 + 1;
            code = code.232;
            D.24033 = imb.b[0];
            *code.231 = D.24033;
            code.1 = code;
            code.233 = code.1;
            code.234 = code.233 + 1;
            code = code.234;
            D.24036 = imb.b[1];
            *code.233 = D.24036;
            code.1 = code;
            code.235 = code.1;
            code.236 = code.235 + 1;
            code = code.236;
            D.24039 = imb.b[2];
            *code.235 = D.24039;
            code.1 = code;
            code.237 = code.1;
            code.238 = code.237 + 1;
            code = code.238;
            D.24042 = imb.b[3];
            *code.237 = D.24042;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24043>;
      <D.24028>:
      if (0 != 0) goto <D.24044>; else goto <D.24045>;
      <D.24044>:
      if (0 != 0) goto <D.24046>; else goto <D.24047>;
      <D.24046>:
      code.1 = code;
      code.239 = code.1;
      code.240 = code.239 + 1;
      code = code.240;
      *code.239 = 44;
      code.1 = code;
      code.241 = code.1;
      code.242 = code.241 + 1;
      code = code.242;
      *code.241 = 36;
      goto <D.24052>;
      <D.24047>:
      if (1 != 0) goto <D.24053>; else goto <D.24054>;
      <D.24053>:
      code.1 = code;
      code.243 = code.1;
      code.244 = code.243 + 1;
      code = code.244;
      *code.243 = 108;
      code.1 = code;
      code.245 = code.1;
      code.246 = code.245 + 1;
      code = code.246;
      *code.245 = 36;
      code.1 = code;
      *code.1 = 32;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24059>;
      <D.24054>:
      code.1 = code;
      code.247 = code.1;
      code.248 = code.247 + 1;
      code = code.248;
      *code.247 = 172;
      code.1 = code;
      code.249 = code.1;
      code.250 = code.249 + 1;
      code = code.250;
      *code.249 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.1 = code;
            code.251 = code.1;
            code.252 = code.251 + 1;
            code = code.252;
            D.24066 = imb.b[0];
            *code.251 = D.24066;
            code.1 = code;
            code.253 = code.1;
            code.254 = code.253 + 1;
            code = code.254;
            D.24069 = imb.b[1];
            *code.253 = D.24069;
            code.1 = code;
            code.255 = code.1;
            code.256 = code.255 + 1;
            code = code.256;
            D.24072 = imb.b[2];
            *code.255 = D.24072;
            code.1 = code;
            code.257 = code.1;
            code.258 = code.257 + 1;
            code = code.258;
            D.24075 = imb.b[3];
            *code.257 = D.24075;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24059>:
      <D.24052>:
      goto <D.22831>;
      <D.24045>:
      if (0 != 0) goto <D.24076>; else goto <D.24077>;
      <D.24076>:
      code.1 = code;
      code.259 = code.1;
      code.260 = code.259 + 1;
      code = code.260;
      *code.259 = 43;
      goto <D.22831>;
      <D.24077>:
      if (1 != 0) goto <D.24080>; else goto <D.24081>;
      <D.24080>:
      code.1 = code;
      code.261 = code.1;
      code.262 = code.261 + 1;
      code = code.262;
      *code.261 = 107;
      code.1 = code;
      *code.1 = 32;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24084>;
      <D.24081>:
      code.1 = code;
      code.263 = code.1;
      code.264 = code.263 + 1;
      code = code.264;
      *code.263 = 171;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.1 = code;
            code.265 = code.1;
            code.266 = code.265 + 1;
            code = code.266;
            D.24089 = imb.b[0];
            *code.265 = D.24089;
            code.1 = code;
            code.267 = code.1;
            code.268 = code.267 + 1;
            code = code.268;
            D.24092 = imb.b[1];
            *code.267 = D.24092;
            code.1 = code;
            code.269 = code.1;
            code.270 = code.269 + 1;
            code = code.270;
            D.24095 = imb.b[2];
            *code.269 = D.24095;
            code.1 = code;
            code.271 = code.1;
            code.272 = code.271 + 1;
            code = code.272;
            D.24098 = imb.b[3];
            *code.271 = D.24098;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24084>:
      <D.22831>:
      <D.24043>:
      if (0 != 0) goto <D.24099>; else goto <D.24100>;
      <D.24099>:
      code.1 = code;
      code.273 = code.1;
      code.274 = code.273 + 1;
      code = code.274;
      *code.273 = 102;
      <D.24100>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.24103>; else goto <D.24104>;
        <D.24103>:
        code.1 = code;
        code.275 = code.1;
        code.276 = code.275 + 1;
        code = code.276;
        D.24107 = _amd64_rex_bits | 64;
        *code.275 = D.24107;
        <D.24104>:
      }
      switch (8) <default: <D.22839>, case 1: <D.22834>, case 2: <D.22836>, case 4: <D.22837>, case 8: <D.22838>>
      <D.22834>:
      code.1 = code;
      code.277 = code.1;
      code.278 = code.277 + 1;
      code = code.278;
      *code.277 = 138;
      goto <D.22835>;
      <D.22836>:
      <D.22837>:
      <D.22838>:
      code.1 = code;
      code.279 = code.1;
      code.280 = code.279 + 1;
      code = code.280;
      *code.279 = 139;
      goto <D.22835>;
      <D.22839>:
      __assert_fail ("0", "exceptions-amd64.c", 215, &__PRETTY_FUNCTION__);
      <D.22835>:
      if (0 != 0) goto <D.24112>; else goto <D.24113>;
      <D.24112>:
      code.1 = code;
      code.281 = code.1;
      code.282 = code.281 + 1;
      code = code.282;
      *code.281 = 53;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.1 = code;
            code.283 = code.1;
            code.284 = code.283 + 1;
            code = code.284;
            D.24118 = imb.b[0];
            *code.283 = D.24118;
            code.1 = code;
            code.285 = code.1;
            code.286 = code.285 + 1;
            code = code.286;
            D.24121 = imb.b[1];
            *code.285 = D.24121;
            code.1 = code;
            code.287 = code.1;
            code.288 = code.287 + 1;
            code = code.288;
            D.24124 = imb.b[2];
            *code.287 = D.24124;
            code.1 = code;
            code.289 = code.1;
            code.290 = code.289 + 1;
            code = code.290;
            D.24127 = imb.b[3];
            *code.289 = D.24127;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24128>;
      <D.24113>:
      if (0 != 0) goto <D.24129>; else goto <D.24130>;
      <D.24129>:
      if (0 != 0) goto <D.24131>; else goto <D.24132>;
      <D.24131>:
      code.1 = code;
      code.291 = code.1;
      code.292 = code.291 + 1;
      code = code.292;
      *code.291 = 52;
      code.1 = code;
      code.293 = code.1;
      code.294 = code.293 + 1;
      code = code.294;
      *code.293 = 36;
      goto <D.24137>;
      <D.24132>:
      if (1 != 0) goto <D.24138>; else goto <D.24139>;
      <D.24138>:
      code.1 = code;
      code.295 = code.1;
      code.296 = code.295 + 1;
      code = code.296;
      *code.295 = 116;
      code.1 = code;
      code.297 = code.1;
      code.298 = code.297 + 1;
      code = code.298;
      *code.297 = 36;
      code.1 = code;
      *code.1 = 48;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24144>;
      <D.24139>:
      code.1 = code;
      code.299 = code.1;
      code.300 = code.299 + 1;
      code = code.300;
      *code.299 = 180;
      code.1 = code;
      code.301 = code.1;
      code.302 = code.301 + 1;
      code = code.302;
      *code.301 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.1 = code;
            code.303 = code.1;
            code.304 = code.303 + 1;
            code = code.304;
            D.24151 = imb.b[0];
            *code.303 = D.24151;
            code.1 = code;
            code.305 = code.1;
            code.306 = code.305 + 1;
            code = code.306;
            D.24154 = imb.b[1];
            *code.305 = D.24154;
            code.1 = code;
            code.307 = code.1;
            code.308 = code.307 + 1;
            code = code.308;
            D.24157 = imb.b[2];
            *code.307 = D.24157;
            code.1 = code;
            code.309 = code.1;
            code.310 = code.309 + 1;
            code = code.310;
            D.24160 = imb.b[3];
            *code.309 = D.24160;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24144>:
      <D.24137>:
      goto <D.22842>;
      <D.24130>:
      if (0 != 0) goto <D.24161>; else goto <D.24162>;
      <D.24161>:
      code.1 = code;
      code.311 = code.1;
      code.312 = code.311 + 1;
      code = code.312;
      *code.311 = 51;
      goto <D.22842>;
      <D.24162>:
      if (1 != 0) goto <D.24165>; else goto <D.24166>;
      <D.24165>:
      code.1 = code;
      code.313 = code.1;
      code.314 = code.313 + 1;
      code = code.314;
      *code.313 = 115;
      code.1 = code;
      *code.1 = 48;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24169>;
      <D.24166>:
      code.1 = code;
      code.315 = code.1;
      code.316 = code.315 + 1;
      code = code.316;
      *code.315 = 179;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.1 = code;
            code.317 = code.1;
            code.318 = code.317 + 1;
            code = code.318;
            D.24174 = imb.b[0];
            *code.317 = D.24174;
            code.1 = code;
            code.319 = code.1;
            code.320 = code.319 + 1;
            code = code.320;
            D.24177 = imb.b[1];
            *code.319 = D.24177;
            code.1 = code;
            code.321 = code.1;
            code.322 = code.321 + 1;
            code = code.322;
            D.24180 = imb.b[2];
            *code.321 = D.24180;
            code.1 = code;
            code.323 = code.1;
            code.324 = code.323 + 1;
            code = code.324;
            D.24183 = imb.b[3];
            *code.323 = D.24183;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24169>:
      <D.22842>:
      <D.24128>:
      if (0 != 0) goto <D.24184>; else goto <D.24185>;
      <D.24184>:
      code.1 = code;
      code.325 = code.1;
      code.326 = code.325 + 1;
      code = code.326;
      *code.325 = 102;
      <D.24185>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.24188>; else goto <D.24189>;
        <D.24188>:
        code.1 = code;
        code.327 = code.1;
        code.328 = code.327 + 1;
        code = code.328;
        D.24192 = _amd64_rex_bits | 64;
        *code.327 = D.24192;
        <D.24189>:
      }
      switch (8) <default: <D.22850>, case 1: <D.22845>, case 2: <D.22847>, case 4: <D.22848>, case 8: <D.22849>>
      <D.22845>:
      code.1 = code;
      code.329 = code.1;
      code.330 = code.329 + 1;
      code = code.330;
      *code.329 = 138;
      goto <D.22846>;
      <D.22847>:
      <D.22848>:
      <D.22849>:
      code.1 = code;
      code.331 = code.1;
      code.332 = code.331 + 1;
      code = code.332;
      *code.331 = 139;
      goto <D.22846>;
      <D.22850>:
      __assert_fail ("0", "exceptions-amd64.c", 216, &__PRETTY_FUNCTION__);
      <D.22846>:
      if (0 != 0) goto <D.24197>; else goto <D.24198>;
      <D.24197>:
      code.1 = code;
      code.333 = code.1;
      code.334 = code.333 + 1;
      code = code.334;
      *code.333 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.1 = code;
            code.335 = code.1;
            code.336 = code.335 + 1;
            code = code.336;
            D.24203 = imb.b[0];
            *code.335 = D.24203;
            code.1 = code;
            code.337 = code.1;
            code.338 = code.337 + 1;
            code = code.338;
            D.24206 = imb.b[1];
            *code.337 = D.24206;
            code.1 = code;
            code.339 = code.1;
            code.340 = code.339 + 1;
            code = code.340;
            D.24209 = imb.b[2];
            *code.339 = D.24209;
            code.1 = code;
            code.341 = code.1;
            code.342 = code.341 + 1;
            code = code.342;
            D.24212 = imb.b[3];
            *code.341 = D.24212;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24213>;
      <D.24198>:
      if (0 != 0) goto <D.24214>; else goto <D.24215>;
      <D.24214>:
      if (0 != 0) goto <D.24216>; else goto <D.24217>;
      <D.24216>:
      code.1 = code;
      code.343 = code.1;
      code.344 = code.343 + 1;
      code = code.344;
      *code.343 = 60;
      code.1 = code;
      code.345 = code.1;
      code.346 = code.345 + 1;
      code = code.346;
      *code.345 = 36;
      goto <D.24222>;
      <D.24217>:
      if (1 != 0) goto <D.24223>; else goto <D.24224>;
      <D.24223>:
      code.1 = code;
      code.347 = code.1;
      code.348 = code.347 + 1;
      code = code.348;
      *code.347 = 124;
      code.1 = code;
      code.349 = code.1;
      code.350 = code.349 + 1;
      code = code.350;
      *code.349 = 36;
      code.1 = code;
      *code.1 = 56;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24229>;
      <D.24224>:
      code.1 = code;
      code.351 = code.1;
      code.352 = code.351 + 1;
      code = code.352;
      *code.351 = 188;
      code.1 = code;
      code.353 = code.1;
      code.354 = code.353 + 1;
      code = code.354;
      *code.353 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.1 = code;
            code.355 = code.1;
            code.356 = code.355 + 1;
            code = code.356;
            D.24236 = imb.b[0];
            *code.355 = D.24236;
            code.1 = code;
            code.357 = code.1;
            code.358 = code.357 + 1;
            code = code.358;
            D.24239 = imb.b[1];
            *code.357 = D.24239;
            code.1 = code;
            code.359 = code.1;
            code.360 = code.359 + 1;
            code = code.360;
            D.24242 = imb.b[2];
            *code.359 = D.24242;
            code.1 = code;
            code.361 = code.1;
            code.362 = code.361 + 1;
            code = code.362;
            D.24245 = imb.b[3];
            *code.361 = D.24245;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24229>:
      <D.24222>:
      goto <D.22853>;
      <D.24215>:
      if (0 != 0) goto <D.24246>; else goto <D.24247>;
      <D.24246>:
      code.1 = code;
      code.363 = code.1;
      code.364 = code.363 + 1;
      code = code.364;
      *code.363 = 59;
      goto <D.22853>;
      <D.24247>:
      if (1 != 0) goto <D.24250>; else goto <D.24251>;
      <D.24250>:
      code.1 = code;
      code.365 = code.1;
      code.366 = code.365 + 1;
      code = code.366;
      *code.365 = 123;
      code.1 = code;
      *code.1 = 56;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24254>;
      <D.24251>:
      code.1 = code;
      code.367 = code.1;
      code.368 = code.367 + 1;
      code = code.368;
      *code.367 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.1 = code;
            code.369 = code.1;
            code.370 = code.369 + 1;
            code = code.370;
            D.24259 = imb.b[0];
            *code.369 = D.24259;
            code.1 = code;
            code.371 = code.1;
            code.372 = code.371 + 1;
            code = code.372;
            D.24262 = imb.b[1];
            *code.371 = D.24262;
            code.1 = code;
            code.373 = code.1;
            code.374 = code.373 + 1;
            code = code.374;
            D.24265 = imb.b[2];
            *code.373 = D.24265;
            code.1 = code;
            code.375 = code.1;
            code.376 = code.375 + 1;
            code = code.376;
            D.24268 = imb.b[3];
            *code.375 = D.24268;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24254>:
      <D.22853>:
      <D.24213>:
      if (0 != 0) goto <D.24269>; else goto <D.24270>;
      <D.24269>:
      code.1 = code;
      code.377 = code.1;
      code.378 = code.377 + 1;
      code = code.378;
      *code.377 = 102;
      <D.24270>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24273>; else goto <D.24274>;
        <D.24273>:
        code.1 = code;
        code.379 = code.1;
        code.380 = code.379 + 1;
        code = code.380;
        D.24277 = _amd64_rex_bits | 64;
        *code.379 = D.24277;
        <D.24274>:
      }
      switch (8) <default: <D.22861>, case 1: <D.22856>, case 2: <D.22858>, case 4: <D.22859>, case 8: <D.22860>>
      <D.22856>:
      code.1 = code;
      code.381 = code.1;
      code.382 = code.381 + 1;
      code = code.382;
      *code.381 = 138;
      goto <D.22857>;
      <D.22858>:
      <D.22859>:
      <D.22860>:
      code.1 = code;
      code.383 = code.1;
      code.384 = code.383 + 1;
      code = code.384;
      *code.383 = 139;
      goto <D.22857>;
      <D.22861>:
      __assert_fail ("0", "exceptions-amd64.c", 220, &__PRETTY_FUNCTION__);
      <D.22857>:
      if (0 != 0) goto <D.24282>; else goto <D.24283>;
      <D.24282>:
      code.1 = code;
      code.385 = code.1;
      code.386 = code.385 + 1;
      code = code.386;
      *code.385 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.1 = code;
            code.387 = code.1;
            code.388 = code.387 + 1;
            code = code.388;
            D.24288 = imb.b[0];
            *code.387 = D.24288;
            code.1 = code;
            code.389 = code.1;
            code.390 = code.389 + 1;
            code = code.390;
            D.24291 = imb.b[1];
            *code.389 = D.24291;
            code.1 = code;
            code.391 = code.1;
            code.392 = code.391 + 1;
            code = code.392;
            D.24294 = imb.b[2];
            *code.391 = D.24294;
            code.1 = code;
            code.393 = code.1;
            code.394 = code.393 + 1;
            code = code.394;
            D.24297 = imb.b[3];
            *code.393 = D.24297;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24298>;
      <D.24283>:
      if (0 != 0) goto <D.24299>; else goto <D.24300>;
      <D.24299>:
      if (0 != 0) goto <D.24301>; else goto <D.24302>;
      <D.24301>:
      code.1 = code;
      code.395 = code.1;
      code.396 = code.395 + 1;
      code = code.396;
      *code.395 = 36;
      code.1 = code;
      code.397 = code.1;
      code.398 = code.397 + 1;
      code = code.398;
      *code.397 = 36;
      goto <D.24307>;
      <D.24302>:
      if (1 != 0) goto <D.24308>; else goto <D.24309>;
      <D.24308>:
      code.1 = code;
      code.399 = code.1;
      code.400 = code.399 + 1;
      code = code.400;
      *code.399 = 100;
      code.1 = code;
      code.401 = code.1;
      code.402 = code.401 + 1;
      code = code.402;
      *code.401 = 36;
      code.1 = code;
      *code.1 = 96;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24314>;
      <D.24309>:
      code.1 = code;
      code.403 = code.1;
      code.404 = code.403 + 1;
      code = code.404;
      *code.403 = 164;
      code.1 = code;
      code.405 = code.1;
      code.406 = code.405 + 1;
      code = code.406;
      *code.405 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.1 = code;
            code.407 = code.1;
            code.408 = code.407 + 1;
            code = code.408;
            D.24321 = imb.b[0];
            *code.407 = D.24321;
            code.1 = code;
            code.409 = code.1;
            code.410 = code.409 + 1;
            code = code.410;
            D.24324 = imb.b[1];
            *code.409 = D.24324;
            code.1 = code;
            code.411 = code.1;
            code.412 = code.411 + 1;
            code = code.412;
            D.24327 = imb.b[2];
            *code.411 = D.24327;
            code.1 = code;
            code.413 = code.1;
            code.414 = code.413 + 1;
            code = code.414;
            D.24330 = imb.b[3];
            *code.413 = D.24330;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24314>:
      <D.24307>:
      goto <D.22864>;
      <D.24300>:
      if (0 != 0) goto <D.24331>; else goto <D.24332>;
      <D.24331>:
      code.1 = code;
      code.415 = code.1;
      code.416 = code.415 + 1;
      code = code.416;
      *code.415 = 35;
      goto <D.22864>;
      <D.24332>:
      if (1 != 0) goto <D.24335>; else goto <D.24336>;
      <D.24335>:
      code.1 = code;
      code.417 = code.1;
      code.418 = code.417 + 1;
      code = code.418;
      *code.417 = 99;
      code.1 = code;
      *code.1 = 96;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24339>;
      <D.24336>:
      code.1 = code;
      code.419 = code.1;
      code.420 = code.419 + 1;
      code = code.420;
      *code.419 = 163;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.1 = code;
            code.421 = code.1;
            code.422 = code.421 + 1;
            code = code.422;
            D.24344 = imb.b[0];
            *code.421 = D.24344;
            code.1 = code;
            code.423 = code.1;
            code.424 = code.423 + 1;
            code = code.424;
            D.24347 = imb.b[1];
            *code.423 = D.24347;
            code.1 = code;
            code.425 = code.1;
            code.426 = code.425 + 1;
            code = code.426;
            D.24350 = imb.b[2];
            *code.425 = D.24350;
            code.1 = code;
            code.427 = code.1;
            code.428 = code.427 + 1;
            code = code.428;
            D.24353 = imb.b[3];
            *code.427 = D.24353;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24339>:
      <D.22864>:
      <D.24298>:
      if (0 != 0) goto <D.24354>; else goto <D.24355>;
      <D.24354>:
      code.1 = code;
      code.429 = code.1;
      code.430 = code.429 + 1;
      code = code.430;
      *code.429 = 102;
      <D.24355>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24358>; else goto <D.24359>;
        <D.24358>:
        code.1 = code;
        code.431 = code.1;
        code.432 = code.431 + 1;
        code = code.432;
        D.24362 = _amd64_rex_bits | 64;
        *code.431 = D.24362;
        <D.24359>:
      }
      switch (8) <default: <D.22872>, case 1: <D.22867>, case 2: <D.22869>, case 4: <D.22870>, case 8: <D.22871>>
      <D.22867>:
      code.1 = code;
      code.433 = code.1;
      code.434 = code.433 + 1;
      code = code.434;
      *code.433 = 138;
      goto <D.22868>;
      <D.22869>:
      <D.22870>:
      <D.22871>:
      code.1 = code;
      code.435 = code.1;
      code.436 = code.435 + 1;
      code = code.436;
      *code.435 = 139;
      goto <D.22868>;
      <D.22872>:
      __assert_fail ("0", "exceptions-amd64.c", 221, &__PRETTY_FUNCTION__);
      <D.22868>:
      if (0 != 0) goto <D.24367>; else goto <D.24368>;
      <D.24367>:
      code.1 = code;
      code.437 = code.1;
      code.438 = code.437 + 1;
      code = code.438;
      *code.437 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.1 = code;
            code.439 = code.1;
            code.440 = code.439 + 1;
            code = code.440;
            D.24373 = imb.b[0];
            *code.439 = D.24373;
            code.1 = code;
            code.441 = code.1;
            code.442 = code.441 + 1;
            code = code.442;
            D.24376 = imb.b[1];
            *code.441 = D.24376;
            code.1 = code;
            code.443 = code.1;
            code.444 = code.443 + 1;
            code = code.444;
            D.24379 = imb.b[2];
            *code.443 = D.24379;
            code.1 = code;
            code.445 = code.1;
            code.446 = code.445 + 1;
            code = code.446;
            D.24382 = imb.b[3];
            *code.445 = D.24382;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24383>;
      <D.24368>:
      if (0 != 0) goto <D.24384>; else goto <D.24385>;
      <D.24384>:
      if (0 != 0) goto <D.24386>; else goto <D.24387>;
      <D.24386>:
      code.1 = code;
      code.447 = code.1;
      code.448 = code.447 + 1;
      code = code.448;
      *code.447 = 44;
      code.1 = code;
      code.449 = code.1;
      code.450 = code.449 + 1;
      code = code.450;
      *code.449 = 36;
      goto <D.24392>;
      <D.24387>:
      if (1 != 0) goto <D.24393>; else goto <D.24394>;
      <D.24393>:
      code.1 = code;
      code.451 = code.1;
      code.452 = code.451 + 1;
      code = code.452;
      *code.451 = 108;
      code.1 = code;
      code.453 = code.1;
      code.454 = code.453 + 1;
      code = code.454;
      *code.453 = 36;
      code.1 = code;
      *code.1 = 104;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24399>;
      <D.24394>:
      code.1 = code;
      code.455 = code.1;
      code.456 = code.455 + 1;
      code = code.456;
      *code.455 = 172;
      code.1 = code;
      code.457 = code.1;
      code.458 = code.457 + 1;
      code = code.458;
      *code.457 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.1 = code;
            code.459 = code.1;
            code.460 = code.459 + 1;
            code = code.460;
            D.24406 = imb.b[0];
            *code.459 = D.24406;
            code.1 = code;
            code.461 = code.1;
            code.462 = code.461 + 1;
            code = code.462;
            D.24409 = imb.b[1];
            *code.461 = D.24409;
            code.1 = code;
            code.463 = code.1;
            code.464 = code.463 + 1;
            code = code.464;
            D.24412 = imb.b[2];
            *code.463 = D.24412;
            code.1 = code;
            code.465 = code.1;
            code.466 = code.465 + 1;
            code = code.466;
            D.24415 = imb.b[3];
            *code.465 = D.24415;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24399>:
      <D.24392>:
      goto <D.22875>;
      <D.24385>:
      if (0 != 0) goto <D.24416>; else goto <D.24417>;
      <D.24416>:
      code.1 = code;
      code.467 = code.1;
      code.468 = code.467 + 1;
      code = code.468;
      *code.467 = 43;
      goto <D.22875>;
      <D.24417>:
      if (1 != 0) goto <D.24420>; else goto <D.24421>;
      <D.24420>:
      code.1 = code;
      code.469 = code.1;
      code.470 = code.469 + 1;
      code = code.470;
      *code.469 = 107;
      code.1 = code;
      *code.1 = 104;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24424>;
      <D.24421>:
      code.1 = code;
      code.471 = code.1;
      code.472 = code.471 + 1;
      code = code.472;
      *code.471 = 171;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.1 = code;
            code.473 = code.1;
            code.474 = code.473 + 1;
            code = code.474;
            D.24429 = imb.b[0];
            *code.473 = D.24429;
            code.1 = code;
            code.475 = code.1;
            code.476 = code.475 + 1;
            code = code.476;
            D.24432 = imb.b[1];
            *code.475 = D.24432;
            code.1 = code;
            code.477 = code.1;
            code.478 = code.477 + 1;
            code = code.478;
            D.24435 = imb.b[2];
            *code.477 = D.24435;
            code.1 = code;
            code.479 = code.1;
            code.480 = code.479 + 1;
            code = code.480;
            D.24438 = imb.b[3];
            *code.479 = D.24438;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24424>:
      <D.22875>:
      <D.24383>:
      if (0 != 0) goto <D.24439>; else goto <D.24440>;
      <D.24439>:
      code.1 = code;
      code.481 = code.1;
      code.482 = code.481 + 1;
      code = code.482;
      *code.481 = 102;
      <D.24440>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24443>; else goto <D.24444>;
        <D.24443>:
        code.1 = code;
        code.483 = code.1;
        code.484 = code.483 + 1;
        code = code.484;
        D.24447 = _amd64_rex_bits | 64;
        *code.483 = D.24447;
        <D.24444>:
      }
      switch (8) <default: <D.22883>, case 1: <D.22878>, case 2: <D.22880>, case 4: <D.22881>, case 8: <D.22882>>
      <D.22878>:
      code.1 = code;
      code.485 = code.1;
      code.486 = code.485 + 1;
      code = code.486;
      *code.485 = 138;
      goto <D.22879>;
      <D.22880>:
      <D.22881>:
      <D.22882>:
      code.1 = code;
      code.487 = code.1;
      code.488 = code.487 + 1;
      code = code.488;
      *code.487 = 139;
      goto <D.22879>;
      <D.22883>:
      __assert_fail ("0", "exceptions-amd64.c", 222, &__PRETTY_FUNCTION__);
      <D.22879>:
      if (0 != 0) goto <D.24452>; else goto <D.24453>;
      <D.24452>:
      code.1 = code;
      code.489 = code.1;
      code.490 = code.489 + 1;
      code = code.490;
      *code.489 = 53;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.1 = code;
            code.491 = code.1;
            code.492 = code.491 + 1;
            code = code.492;
            D.24458 = imb.b[0];
            *code.491 = D.24458;
            code.1 = code;
            code.493 = code.1;
            code.494 = code.493 + 1;
            code = code.494;
            D.24461 = imb.b[1];
            *code.493 = D.24461;
            code.1 = code;
            code.495 = code.1;
            code.496 = code.495 + 1;
            code = code.496;
            D.24464 = imb.b[2];
            *code.495 = D.24464;
            code.1 = code;
            code.497 = code.1;
            code.498 = code.497 + 1;
            code = code.498;
            D.24467 = imb.b[3];
            *code.497 = D.24467;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24468>;
      <D.24453>:
      if (0 != 0) goto <D.24469>; else goto <D.24470>;
      <D.24469>:
      if (0 != 0) goto <D.24471>; else goto <D.24472>;
      <D.24471>:
      code.1 = code;
      code.499 = code.1;
      code.500 = code.499 + 1;
      code = code.500;
      *code.499 = 52;
      code.1 = code;
      code.501 = code.1;
      code.502 = code.501 + 1;
      code = code.502;
      *code.501 = 36;
      goto <D.24477>;
      <D.24472>:
      if (1 != 0) goto <D.24478>; else goto <D.24479>;
      <D.24478>:
      code.1 = code;
      code.503 = code.1;
      code.504 = code.503 + 1;
      code = code.504;
      *code.503 = 116;
      code.1 = code;
      code.505 = code.1;
      code.506 = code.505 + 1;
      code = code.506;
      *code.505 = 36;
      code.1 = code;
      *code.1 = 112;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24484>;
      <D.24479>:
      code.1 = code;
      code.507 = code.1;
      code.508 = code.507 + 1;
      code = code.508;
      *code.507 = 180;
      code.1 = code;
      code.509 = code.1;
      code.510 = code.509 + 1;
      code = code.510;
      *code.509 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.1 = code;
            code.511 = code.1;
            code.512 = code.511 + 1;
            code = code.512;
            D.24491 = imb.b[0];
            *code.511 = D.24491;
            code.1 = code;
            code.513 = code.1;
            code.514 = code.513 + 1;
            code = code.514;
            D.24494 = imb.b[1];
            *code.513 = D.24494;
            code.1 = code;
            code.515 = code.1;
            code.516 = code.515 + 1;
            code = code.516;
            D.24497 = imb.b[2];
            *code.515 = D.24497;
            code.1 = code;
            code.517 = code.1;
            code.518 = code.517 + 1;
            code = code.518;
            D.24500 = imb.b[3];
            *code.517 = D.24500;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24484>:
      <D.24477>:
      goto <D.22886>;
      <D.24470>:
      if (0 != 0) goto <D.24501>; else goto <D.24502>;
      <D.24501>:
      code.1 = code;
      code.519 = code.1;
      code.520 = code.519 + 1;
      code = code.520;
      *code.519 = 51;
      goto <D.22886>;
      <D.24502>:
      if (1 != 0) goto <D.24505>; else goto <D.24506>;
      <D.24505>:
      code.1 = code;
      code.521 = code.1;
      code.522 = code.521 + 1;
      code = code.522;
      *code.521 = 115;
      code.1 = code;
      *code.1 = 112;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24509>;
      <D.24506>:
      code.1 = code;
      code.523 = code.1;
      code.524 = code.523 + 1;
      code = code.524;
      *code.523 = 179;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.1 = code;
            code.525 = code.1;
            code.526 = code.525 + 1;
            code = code.526;
            D.24514 = imb.b[0];
            *code.525 = D.24514;
            code.1 = code;
            code.527 = code.1;
            code.528 = code.527 + 1;
            code = code.528;
            D.24517 = imb.b[1];
            *code.527 = D.24517;
            code.1 = code;
            code.529 = code.1;
            code.530 = code.529 + 1;
            code = code.530;
            D.24520 = imb.b[2];
            *code.529 = D.24520;
            code.1 = code;
            code.531 = code.1;
            code.532 = code.531 + 1;
            code = code.532;
            D.24523 = imb.b[3];
            *code.531 = D.24523;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24509>:
      <D.22886>:
      <D.24468>:
      if (0 != 0) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      code.1 = code;
      code.533 = code.1;
      code.534 = code.533 + 1;
      code = code.534;
      *code.533 = 102;
      <D.24525>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24528>; else goto <D.24529>;
        <D.24528>:
        code.1 = code;
        code.535 = code.1;
        code.536 = code.535 + 1;
        code = code.536;
        D.24532 = _amd64_rex_bits | 64;
        *code.535 = D.24532;
        <D.24529>:
      }
      switch (8) <default: <D.22894>, case 1: <D.22889>, case 2: <D.22891>, case 4: <D.22892>, case 8: <D.22893>>
      <D.22889>:
      code.1 = code;
      code.537 = code.1;
      code.538 = code.537 + 1;
      code = code.538;
      *code.537 = 138;
      goto <D.22890>;
      <D.22891>:
      <D.22892>:
      <D.22893>:
      code.1 = code;
      code.539 = code.1;
      code.540 = code.539 + 1;
      code = code.540;
      *code.539 = 139;
      goto <D.22890>;
      <D.22894>:
      __assert_fail ("0", "exceptions-amd64.c", 224, &__PRETTY_FUNCTION__);
      <D.22890>:
      if (0 != 0) goto <D.24537>; else goto <D.24538>;
      <D.24537>:
      code.1 = code;
      code.541 = code.1;
      code.542 = code.541 + 1;
      code = code.542;
      *code.541 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.1 = code;
            code.543 = code.1;
            code.544 = code.543 + 1;
            code = code.544;
            D.24543 = imb.b[0];
            *code.543 = D.24543;
            code.1 = code;
            code.545 = code.1;
            code.546 = code.545 + 1;
            code = code.546;
            D.24546 = imb.b[1];
            *code.545 = D.24546;
            code.1 = code;
            code.547 = code.1;
            code.548 = code.547 + 1;
            code = code.548;
            D.24549 = imb.b[2];
            *code.547 = D.24549;
            code.1 = code;
            code.549 = code.1;
            code.550 = code.549 + 1;
            code = code.550;
            D.24552 = imb.b[3];
            *code.549 = D.24552;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24553>;
      <D.24538>:
      if (0 != 0) goto <D.24554>; else goto <D.24555>;
      <D.24554>:
      if (0 != 0) goto <D.24556>; else goto <D.24557>;
      <D.24556>:
      code.1 = code;
      code.551 = code.1;
      code.552 = code.551 + 1;
      code = code.552;
      *code.551 = 60;
      code.1 = code;
      code.553 = code.1;
      code.554 = code.553 + 1;
      code = code.554;
      *code.553 = 36;
      goto <D.24562>;
      <D.24557>:
      if (1 != 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      code.1 = code;
      code.555 = code.1;
      code.556 = code.555 + 1;
      code = code.556;
      *code.555 = 124;
      code.1 = code;
      code.557 = code.1;
      code.558 = code.557 + 1;
      code = code.558;
      *code.557 = 36;
      code.1 = code;
      *code.1 = 120;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24569>;
      <D.24564>:
      code.1 = code;
      code.559 = code.1;
      code.560 = code.559 + 1;
      code = code.560;
      *code.559 = 188;
      code.1 = code;
      code.561 = code.1;
      code.562 = code.561 + 1;
      code = code.562;
      *code.561 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.1 = code;
            code.563 = code.1;
            code.564 = code.563 + 1;
            code = code.564;
            D.24576 = imb.b[0];
            *code.563 = D.24576;
            code.1 = code;
            code.565 = code.1;
            code.566 = code.565 + 1;
            code = code.566;
            D.24579 = imb.b[1];
            *code.565 = D.24579;
            code.1 = code;
            code.567 = code.1;
            code.568 = code.567 + 1;
            code = code.568;
            D.24582 = imb.b[2];
            *code.567 = D.24582;
            code.1 = code;
            code.569 = code.1;
            code.570 = code.569 + 1;
            code = code.570;
            D.24585 = imb.b[3];
            *code.569 = D.24585;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24569>:
      <D.24562>:
      goto <D.22897>;
      <D.24555>:
      if (0 != 0) goto <D.24586>; else goto <D.24587>;
      <D.24586>:
      code.1 = code;
      code.571 = code.1;
      code.572 = code.571 + 1;
      code = code.572;
      *code.571 = 59;
      goto <D.22897>;
      <D.24587>:
      if (1 != 0) goto <D.24590>; else goto <D.24591>;
      <D.24590>:
      code.1 = code;
      code.573 = code.1;
      code.574 = code.573 + 1;
      code = code.574;
      *code.573 = 123;
      code.1 = code;
      *code.1 = 120;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24594>;
      <D.24591>:
      code.1 = code;
      code.575 = code.1;
      code.576 = code.575 + 1;
      code = code.576;
      *code.575 = 187;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.1 = code;
            code.577 = code.1;
            code.578 = code.577 + 1;
            code = code.578;
            D.24599 = imb.b[0];
            *code.577 = D.24599;
            code.1 = code;
            code.579 = code.1;
            code.580 = code.579 + 1;
            code = code.580;
            D.24602 = imb.b[1];
            *code.579 = D.24602;
            code.1 = code;
            code.581 = code.1;
            code.582 = code.581 + 1;
            code = code.582;
            D.24605 = imb.b[2];
            *code.581 = D.24605;
            code.1 = code;
            code.583 = code.1;
            code.584 = code.583 + 1;
            code = code.584;
            D.24608 = imb.b[3];
            *code.583 = D.24608;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24594>:
      <D.22897>:
      <D.24553>:
      if (0 != 0) goto <D.24609>; else goto <D.24610>;
      <D.24609>:
      code.1 = code;
      code.585 = code.1;
      code.586 = code.585 + 1;
      code = code.586;
      *code.585 = 102;
      <D.24610>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24613>; else goto <D.24614>;
        <D.24613>:
        code.1 = code;
        code.587 = code.1;
        code.588 = code.587 + 1;
        code = code.588;
        D.24617 = _amd64_rex_bits | 64;
        *code.587 = D.24617;
        <D.24614>:
      }
      switch (8) <default: <D.22905>, case 1: <D.22900>, case 2: <D.22902>, case 4: <D.22903>, case 8: <D.22904>>
      <D.22900>:
      code.1 = code;
      code.589 = code.1;
      code.590 = code.589 + 1;
      code = code.590;
      *code.589 = 138;
      goto <D.22901>;
      <D.22902>:
      <D.22903>:
      <D.22904>:
      code.1 = code;
      code.591 = code.1;
      code.592 = code.591 + 1;
      code = code.592;
      *code.591 = 139;
      goto <D.22901>;
      <D.22905>:
      __assert_fail ("0", "exceptions-amd64.c", 235, &__PRETTY_FUNCTION__);
      <D.22901>:
      if (0 != 0) goto <D.24622>; else goto <D.24623>;
      <D.24622>:
      code.1 = code;
      code.593 = code.1;
      code.594 = code.593 + 1;
      code = code.594;
      *code.593 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.1 = code;
            code.595 = code.1;
            code.596 = code.595 + 1;
            code = code.596;
            D.24628 = imb.b[0];
            *code.595 = D.24628;
            code.1 = code;
            code.597 = code.1;
            code.598 = code.597 + 1;
            code = code.598;
            D.24631 = imb.b[1];
            *code.597 = D.24631;
            code.1 = code;
            code.599 = code.1;
            code.600 = code.599 + 1;
            code = code.600;
            D.24634 = imb.b[2];
            *code.599 = D.24634;
            code.1 = code;
            code.601 = code.1;
            code.602 = code.601 + 1;
            code = code.602;
            D.24637 = imb.b[3];
            *code.601 = D.24637;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24638>;
      <D.24623>:
      if (0 != 0) goto <D.24639>; else goto <D.24640>;
      <D.24639>:
      if (0 != 0) goto <D.24641>; else goto <D.24642>;
      <D.24641>:
      code.1 = code;
      code.603 = code.1;
      code.604 = code.603 + 1;
      code = code.604;
      *code.603 = 4;
      code.1 = code;
      code.605 = code.1;
      code.606 = code.605 + 1;
      code = code.606;
      *code.605 = 36;
      goto <D.24647>;
      <D.24642>:
      if (1 != 0) goto <D.24648>; else goto <D.24649>;
      <D.24648>:
      code.1 = code;
      code.607 = code.1;
      code.608 = code.607 + 1;
      code = code.608;
      *code.607 = 68;
      code.1 = code;
      code.609 = code.1;
      code.610 = code.609 + 1;
      code = code.610;
      *code.609 = 36;
      code.1 = code;
      *code.1 = 40;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24654>;
      <D.24649>:
      code.1 = code;
      code.611 = code.1;
      code.612 = code.611 + 1;
      code = code.612;
      *code.611 = 132;
      code.1 = code;
      code.613 = code.1;
      code.614 = code.613 + 1;
      code = code.614;
      *code.613 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.1 = code;
            code.615 = code.1;
            code.616 = code.615 + 1;
            code = code.616;
            D.24661 = imb.b[0];
            *code.615 = D.24661;
            code.1 = code;
            code.617 = code.1;
            code.618 = code.617 + 1;
            code = code.618;
            D.24664 = imb.b[1];
            *code.617 = D.24664;
            code.1 = code;
            code.619 = code.1;
            code.620 = code.619 + 1;
            code = code.620;
            D.24667 = imb.b[2];
            *code.619 = D.24667;
            code.1 = code;
            code.621 = code.1;
            code.622 = code.621 + 1;
            code = code.622;
            D.24670 = imb.b[3];
            *code.621 = D.24670;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24654>:
      <D.24647>:
      goto <D.22908>;
      <D.24640>:
      if (0 != 0) goto <D.24671>; else goto <D.24672>;
      <D.24671>:
      code.1 = code;
      code.623 = code.1;
      code.624 = code.623 + 1;
      code = code.624;
      *code.623 = 3;
      goto <D.22908>;
      <D.24672>:
      if (1 != 0) goto <D.24675>; else goto <D.24676>;
      <D.24675>:
      code.1 = code;
      code.625 = code.1;
      code.626 = code.625 + 1;
      code = code.626;
      *code.625 = 67;
      code.1 = code;
      *code.1 = 40;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24679>;
      <D.24676>:
      code.1 = code;
      code.627 = code.1;
      code.628 = code.627 + 1;
      code = code.628;
      *code.627 = 131;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.1 = code;
            code.629 = code.1;
            code.630 = code.629 + 1;
            code = code.630;
            D.24684 = imb.b[0];
            *code.629 = D.24684;
            code.1 = code;
            code.631 = code.1;
            code.632 = code.631 + 1;
            code = code.632;
            D.24687 = imb.b[1];
            *code.631 = D.24687;
            code.1 = code;
            code.633 = code.1;
            code.634 = code.633 + 1;
            code = code.634;
            D.24690 = imb.b[2];
            *code.633 = D.24690;
            code.1 = code;
            code.635 = code.1;
            code.636 = code.635 + 1;
            code = code.636;
            D.24693 = imb.b[3];
            *code.635 = D.24693;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24679>:
      <D.22908>:
      <D.24638>:
      if (0 != 0) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      code.1 = code;
      code.637 = code.1;
      code.638 = code.637 + 1;
      code = code.638;
      *code.637 = 102;
      <D.24695>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.24698>; else goto <D.24699>;
        <D.24698>:
        code.1 = code;
        code.639 = code.1;
        code.640 = code.639 + 1;
        code = code.640;
        D.24702 = _amd64_rex_bits | 64;
        *code.639 = D.24702;
        <D.24699>:
      }
      switch (8) <default: <D.22916>, case 1: <D.22911>, case 2: <D.22913>, case 4: <D.22914>, case 8: <D.22915>>
      <D.22911>:
      code.1 = code;
      code.641 = code.1;
      code.642 = code.641 + 1;
      code = code.642;
      *code.641 = 138;
      goto <D.22912>;
      <D.22913>:
      <D.22914>:
      <D.22915>:
      code.1 = code;
      code.643 = code.1;
      code.644 = code.643 + 1;
      code = code.644;
      *code.643 = 139;
      goto <D.22912>;
      <D.22916>:
      __assert_fail ("0", "exceptions-amd64.c", 236, &__PRETTY_FUNCTION__);
      <D.22912>:
      if (0 != 0) goto <D.24707>; else goto <D.24708>;
      <D.24707>:
      code.1 = code;
      code.645 = code.1;
      code.646 = code.645 + 1;
      code = code.646;
      *code.645 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 128;
            code.1 = code;
            code.647 = code.1;
            code.648 = code.647 + 1;
            code = code.648;
            D.24713 = imb.b[0];
            *code.647 = D.24713;
            code.1 = code;
            code.649 = code.1;
            code.650 = code.649 + 1;
            code = code.650;
            D.24716 = imb.b[1];
            *code.649 = D.24716;
            code.1 = code;
            code.651 = code.1;
            code.652 = code.651 + 1;
            code = code.652;
            D.24719 = imb.b[2];
            *code.651 = D.24719;
            code.1 = code;
            code.653 = code.1;
            code.654 = code.653 + 1;
            code = code.654;
            D.24722 = imb.b[3];
            *code.653 = D.24722;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24723>;
      <D.24708>:
      if (0 != 0) goto <D.24724>; else goto <D.24725>;
      <D.24724>:
      if (0 != 0) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      code.1 = code;
      code.655 = code.1;
      code.656 = code.655 + 1;
      code = code.656;
      *code.655 = 28;
      code.1 = code;
      code.657 = code.1;
      code.658 = code.657 + 1;
      code = code.658;
      *code.657 = 36;
      goto <D.24732>;
      <D.24727>:
      if (0 != 0) goto <D.24733>; else goto <D.24734>;
      <D.24733>:
      code.1 = code;
      code.659 = code.1;
      code.660 = code.659 + 1;
      code = code.660;
      *code.659 = 92;
      code.1 = code;
      code.661 = code.1;
      code.662 = code.661 + 1;
      code = code.662;
      *code.661 = 36;
      code.1 = code;
      *code.1 = 128;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24739>;
      <D.24734>:
      code.1 = code;
      code.663 = code.1;
      code.664 = code.663 + 1;
      code = code.664;
      *code.663 = 156;
      code.1 = code;
      code.665 = code.1;
      code.666 = code.665 + 1;
      code = code.666;
      *code.665 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 128;
            code.1 = code;
            code.667 = code.1;
            code.668 = code.667 + 1;
            code = code.668;
            D.24746 = imb.b[0];
            *code.667 = D.24746;
            code.1 = code;
            code.669 = code.1;
            code.670 = code.669 + 1;
            code = code.670;
            D.24749 = imb.b[1];
            *code.669 = D.24749;
            code.1 = code;
            code.671 = code.1;
            code.672 = code.671 + 1;
            code = code.672;
            D.24752 = imb.b[2];
            *code.671 = D.24752;
            code.1 = code;
            code.673 = code.1;
            code.674 = code.673 + 1;
            code = code.674;
            D.24755 = imb.b[3];
            *code.673 = D.24755;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24739>:
      <D.24732>:
      goto <D.22919>;
      <D.24725>:
      if (0 != 0) goto <D.24756>; else goto <D.24757>;
      <D.24756>:
      code.1 = code;
      code.675 = code.1;
      code.676 = code.675 + 1;
      code = code.676;
      *code.675 = 27;
      goto <D.22919>;
      <D.24757>:
      if (0 != 0) goto <D.24760>; else goto <D.24761>;
      <D.24760>:
      code.1 = code;
      code.677 = code.1;
      code.678 = code.677 + 1;
      code = code.678;
      *code.677 = 91;
      code.1 = code;
      *code.1 = 128;
      code.1 = code;
      code.38 = code.1 + 1;
      code = code.38;
      goto <D.24764>;
      <D.24761>:
      code.1 = code;
      code.679 = code.1;
      code.680 = code.679 + 1;
      code = code.680;
      *code.679 = 155;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 128;
            code.1 = code;
            code.681 = code.1;
            code.682 = code.681 + 1;
            code = code.682;
            D.24769 = imb.b[0];
            *code.681 = D.24769;
            code.1 = code;
            code.683 = code.1;
            code.684 = code.683 + 1;
            code = code.684;
            D.24772 = imb.b[1];
            *code.683 = D.24772;
            code.1 = code;
            code.685 = code.1;
            code.686 = code.685 + 1;
            code = code.686;
            D.24775 = imb.b[2];
            *code.685 = D.24775;
            code.1 = code;
            code.687 = code.1;
            code.688 = code.687 + 1;
            code = code.688;
            D.24778 = imb.b[3];
            *code.687 = D.24778;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24764>:
      <D.22919>:
      <D.24723>:
      if (0 != 0) goto <D.24779>; else goto <D.24780>;
      <D.24779>:
      code.1 = code;
      code.689 = code.1;
      code.690 = code.689 + 1;
      code = code.690;
      *code.689 = 102;
      <D.24780>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.24783>; else goto <D.24784>;
        <D.24783>:
        code.1 = code;
        code.691 = code.1;
        code.692 = code.691 + 1;
        code = code.692;
        D.24787 = _amd64_rex_bits | 64;
        *code.691 = D.24787;
        <D.24784>:
      }
      switch (8) <default: <D.22927>, case 1: <D.22922>, case 2: <D.22924>, case 4: <D.22925>, case 8: <D.22926>>
      <D.22922>:
      code.1 = code;
      code.693 = code.1;
      code.694 = code.693 + 1;
      code = code.694;
      *code.693 = 138;
      goto <D.22923>;
      <D.22924>:
      <D.22925>:
      <D.22926>:
      code.1 = code;
      code.695 = code.1;
      code.696 = code.695 + 1;
      code = code.696;
      *code.695 = 139;
      goto <D.22923>;
      <D.22927>:
      __assert_fail ("0", "exceptions-amd64.c", 237, &__PRETTY_FUNCTION__);
      <D.22923>:
      code.1 = code;
      code.697 = code.1;
      code.698 = code.697 + 1;
      code = code.698;
      *code.697 = 224;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.24794>; else goto <D.24795>;
        <D.24794>:
        code.1 = code;
        code.699 = code.1;
        code.700 = code.699 + 1;
        code = code.700;
        D.24798 = _amd64_rex_bits | 64;
        *code.699 = D.24798;
        <D.24795>:
      }
      code.1 = code;
      code.701 = code.1;
      code.702 = code.701 + 1;
      code = code.702;
      *code.701 = 255;
      code.1 = code;
      code.703 = code.1;
      code.704 = code.703 + 1;
      code = code.704;
      *code.703 = 227;
      nacl_global_codeman_validate (&start, 256, &code);
      code.1 = code;
      code.705 = (long int) code.1;
      start.706 = start;
      start.707 = (long int) start.706;
      D.24806 = code.705 - start.707;
      D.24807 = (int) D.24806;
      start.706 = start;
      mono_arch_flush_icache (start.706, D.24807);
      if (info != 0B) goto <D.24808>; else goto <D.24809>;
      <D.24808>:
      code.1 = code;
      code.705 = (long int) code.1;
      start.706 = start;
      start.707 = (long int) start.706;
      D.24806 = code.705 - start.707;
      D.24810 = (unsigned int) D.24806;
      start.706 = start;
      D.24811 = mono_tramp_info_create ("restore_context", start.706, D.24810, ji, unwind_ops);
      *info = D.24811;
      <D.24809>:
      D.24812 = start;
      return D.24812;
    }
  finally
    {
      start = {CLOBBER};
      code = {CLOBBER};
    }
}


mono_arch_get_call_filter (struct MonoTrampInfo * * info, gboolean aot)
{
  int kMaxCodeSize.708;
  void * code.709;
  guint8 * code.710;
  guint8 * start.711;
  guint8 * code.712;
  guint8 * code.713;
  unsigned char D.24823;
  guint8 * code.714;
  guint8 * code.715;
  guint8 * code.716;
  guint8 * code.717;
  guint8 * code.718;
  guint8 * code.719;
  unsigned char D.24834;
  guint8 * code.720;
  guint8 * code.721;
  guint8 * code.722;
  guint8 * code.723;
  guint8 * code.724;
  guint8 * code.725;
  int D.24841;
  int D.24842;
  _Bool D.24845;
  guint8 * code.726;
  guint8 * code.727;
  unsigned char D.24850;
  guint8 * code.728;
  guint8 * code.729;
  unsigned char D.24853;
  unsigned char D.24854;
  unsigned char D.24855;
  guint8 * code.730;
  guint8 * code.731;
  unsigned char D.24860;
  guint8 * code.732;
  guint8 * code.733;
  unsigned int D.24863;
  guint8 * code.734;
  guint8 * code.735;
  unsigned char D.24872;
  guint8 * code.736;
  guint8 * code.737;
  guint8 * code.738;
  guint8 * code.739;
  guint8 * code.740;
  guint8 * code.741;
  guint8 * code.742;
  unsigned char D.24885;
  guint8 * code.743;
  guint8 * code.744;
  guint8 * code.745;
  guint8 * code.746;
  unsigned char D.24890;
  guint8 * code.747;
  guint8 * code.748;
  unsigned char D.24893;
  guint8 * code.749;
  guint8 * code.750;
  unsigned char D.24896;
  guint8 * code.751;
  guint8 * code.752;
  unsigned char D.24899;
  guint8 * code.753;
  guint8 * code.754;
  unsigned char D.24905;
  guint8 * code.755;
  guint8 * code.756;
  guint8 * code.757;
  guint8 * code.758;
  guint8 * code.759;
  guint8 * code.760;
  unsigned char D.24912;
  guint8 * code.761;
  guint8 * code.762;
  unsigned char D.24915;
  guint8 * code.763;
  guint8 * code.764;
  unsigned char D.24918;
  guint8 * code.765;
  guint8 * code.766;
  unsigned char D.24921;
  guint8 * code.767;
  guint8 * code.768;
  guint8 * code.769;
  guint8 * code.770;
  unsigned char D.24930;
  guint8 * code.771;
  guint8 * code.772;
  guint8 * code.773;
  guint8 * code.774;
  guint8 * code.775;
  guint8 * code.776;
  guint8 * code.777;
  guint8 * code.778;
  unsigned char D.24941;
  guint8 * code.779;
  guint8 * code.780;
  unsigned char D.24944;
  guint8 * code.781;
  guint8 * code.782;
  unsigned char D.24947;
  guint8 * code.783;
  guint8 * code.784;
  unsigned char D.24950;
  guint8 * code.785;
  guint8 * code.786;
  guint8 * code.787;
  guint8 * code.788;
  guint8 * code.789;
  guint8 * code.790;
  guint8 * code.791;
  guint8 * code.792;
  guint8 * code.793;
  guint8 * code.794;
  guint8 * code.795;
  guint8 * code.796;
  guint8 * code.797;
  guint8 * code.798;
  unsigned char D.24974;
  guint8 * code.799;
  guint8 * code.800;
  unsigned char D.24977;
  guint8 * code.801;
  guint8 * code.802;
  unsigned char D.24980;
  guint8 * code.803;
  guint8 * code.804;
  unsigned char D.24983;
  guint8 * code.805;
  guint8 * code.806;
  guint8 * code.807;
  guint8 * code.808;
  guint8 * code.809;
  guint8 * code.810;
  guint8 * code.811;
  guint8 * code.812;
  unsigned char D.24997;
  guint8 * code.813;
  guint8 * code.814;
  unsigned char D.25000;
  guint8 * code.815;
  guint8 * code.816;
  unsigned char D.25003;
  guint8 * code.817;
  guint8 * code.818;
  unsigned char D.25006;
  guint8 * code.819;
  guint8 * code.820;
  guint8 * code.821;
  guint8 * code.822;
  unsigned char D.25015;
  guint8 * code.823;
  guint8 * code.824;
  guint8 * code.825;
  guint8 * code.826;
  guint8 * code.827;
  guint8 * code.828;
  guint8 * code.829;
  guint8 * code.830;
  unsigned char D.25026;
  guint8 * code.831;
  guint8 * code.832;
  unsigned char D.25029;
  guint8 * code.833;
  guint8 * code.834;
  unsigned char D.25032;
  guint8 * code.835;
  guint8 * code.836;
  unsigned char D.25035;
  guint8 * code.837;
  guint8 * code.838;
  guint8 * code.839;
  guint8 * code.840;
  guint8 * code.841;
  guint8 * code.842;
  guint8 * code.843;
  guint8 * code.844;
  guint8 * code.845;
  guint8 * code.846;
  guint8 * code.847;
  guint8 * code.848;
  guint8 * code.849;
  guint8 * code.850;
  unsigned char D.25059;
  guint8 * code.851;
  guint8 * code.852;
  unsigned char D.25062;
  guint8 * code.853;
  guint8 * code.854;
  unsigned char D.25065;
  guint8 * code.855;
  guint8 * code.856;
  unsigned char D.25068;
  guint8 * code.857;
  guint8 * code.858;
  guint8 * code.859;
  guint8 * code.860;
  guint8 * code.861;
  guint8 * code.862;
  guint8 * code.863;
  guint8 * code.864;
  unsigned char D.25082;
  guint8 * code.865;
  guint8 * code.866;
  unsigned char D.25085;
  guint8 * code.867;
  guint8 * code.868;
  unsigned char D.25088;
  guint8 * code.869;
  guint8 * code.870;
  unsigned char D.25091;
  guint8 * code.871;
  guint8 * code.872;
  guint8 * code.873;
  guint8 * code.874;
  unsigned char D.25100;
  guint8 * code.875;
  guint8 * code.876;
  guint8 * code.877;
  guint8 * code.878;
  guint8 * code.879;
  guint8 * code.880;
  guint8 * code.881;
  guint8 * code.882;
  unsigned char D.25111;
  guint8 * code.883;
  guint8 * code.884;
  unsigned char D.25114;
  guint8 * code.885;
  guint8 * code.886;
  unsigned char D.25117;
  guint8 * code.887;
  guint8 * code.888;
  unsigned char D.25120;
  guint8 * code.889;
  guint8 * code.890;
  guint8 * code.891;
  guint8 * code.892;
  guint8 * code.893;
  guint8 * code.894;
  guint8 * code.895;
  guint8 * code.896;
  guint8 * code.897;
  guint8 * code.898;
  guint8 * code.899;
  guint8 * code.900;
  guint8 * code.901;
  guint8 * code.902;
  unsigned char D.25144;
  guint8 * code.903;
  guint8 * code.904;
  unsigned char D.25147;
  guint8 * code.905;
  guint8 * code.906;
  unsigned char D.25150;
  guint8 * code.907;
  guint8 * code.908;
  unsigned char D.25153;
  guint8 * code.909;
  guint8 * code.910;
  guint8 * code.911;
  guint8 * code.912;
  guint8 * code.913;
  guint8 * code.914;
  guint8 * code.915;
  guint8 * code.916;
  unsigned char D.25167;
  guint8 * code.917;
  guint8 * code.918;
  unsigned char D.25170;
  guint8 * code.919;
  guint8 * code.920;
  unsigned char D.25173;
  guint8 * code.921;
  guint8 * code.922;
  unsigned char D.25176;
  guint8 * code.923;
  guint8 * code.924;
  guint8 * code.925;
  guint8 * code.926;
  unsigned char D.25185;
  guint8 * code.927;
  guint8 * code.928;
  guint8 * code.929;
  guint8 * code.930;
  guint8 * code.931;
  guint8 * code.932;
  guint8 * code.933;
  guint8 * code.934;
  unsigned char D.25196;
  guint8 * code.935;
  guint8 * code.936;
  unsigned char D.25199;
  guint8 * code.937;
  guint8 * code.938;
  unsigned char D.25202;
  guint8 * code.939;
  guint8 * code.940;
  unsigned char D.25205;
  guint8 * code.941;
  guint8 * code.942;
  guint8 * code.943;
  guint8 * code.944;
  guint8 * code.945;
  guint8 * code.946;
  guint8 * code.947;
  guint8 * code.948;
  guint8 * code.949;
  guint8 * code.950;
  guint8 * code.951;
  guint8 * code.952;
  guint8 * code.953;
  guint8 * code.954;
  unsigned char D.25229;
  guint8 * code.955;
  guint8 * code.956;
  unsigned char D.25232;
  guint8 * code.957;
  guint8 * code.958;
  unsigned char D.25235;
  guint8 * code.959;
  guint8 * code.960;
  unsigned char D.25238;
  guint8 * code.961;
  guint8 * code.962;
  guint8 * code.963;
  guint8 * code.964;
  guint8 * code.965;
  guint8 * code.966;
  guint8 * code.967;
  guint8 * code.968;
  unsigned char D.25252;
  guint8 * code.969;
  guint8 * code.970;
  unsigned char D.25255;
  guint8 * code.971;
  guint8 * code.972;
  unsigned char D.25258;
  guint8 * code.973;
  guint8 * code.974;
  unsigned char D.25261;
  guint8 * code.975;
  guint8 * code.976;
  guint8 * code.977;
  guint8 * code.978;
  unsigned char D.25270;
  guint8 * code.979;
  guint8 * code.980;
  guint8 * code.981;
  guint8 * code.982;
  guint8 * code.983;
  guint8 * code.984;
  guint8 * code.985;
  guint8 * code.986;
  unsigned char D.25281;
  guint8 * code.987;
  guint8 * code.988;
  unsigned char D.25284;
  guint8 * code.989;
  guint8 * code.990;
  unsigned char D.25287;
  guint8 * code.991;
  guint8 * code.992;
  unsigned char D.25290;
  guint8 * code.993;
  guint8 * code.994;
  guint8 * code.995;
  guint8 * code.996;
  guint8 * code.997;
  guint8 * code.998;
  guint8 * code.999;
  guint8 * code.1000;
  guint8 * code.1001;
  guint8 * code.1002;
  guint8 * code.1003;
  guint8 * code.1004;
  guint8 * code.1005;
  guint8 * code.1006;
  unsigned char D.25314;
  guint8 * code.1007;
  guint8 * code.1008;
  unsigned char D.25317;
  guint8 * code.1009;
  guint8 * code.1010;
  unsigned char D.25320;
  guint8 * code.1011;
  guint8 * code.1012;
  unsigned char D.25323;
  guint8 * code.1013;
  guint8 * code.1014;
  guint8 * code.1015;
  guint8 * code.1016;
  guint8 * code.1017;
  guint8 * code.1018;
  guint8 * code.1019;
  guint8 * code.1020;
  unsigned char D.25337;
  guint8 * code.1021;
  guint8 * code.1022;
  unsigned char D.25340;
  guint8 * code.1023;
  guint8 * code.1024;
  unsigned char D.25343;
  guint8 * code.1025;
  guint8 * code.1026;
  unsigned char D.25346;
  guint8 * code.1027;
  guint8 * code.1028;
  guint8 * code.1029;
  guint8 * code.1030;
  unsigned char D.25355;
  guint8 * code.1031;
  guint8 * code.1032;
  guint8 * code.1033;
  guint8 * code.1034;
  guint8 * code.1035;
  guint8 * code.1036;
  guint8 * code.1037;
  guint8 * code.1038;
  unsigned char D.25366;
  guint8 * code.1039;
  guint8 * code.1040;
  unsigned char D.25369;
  guint8 * code.1041;
  guint8 * code.1042;
  unsigned char D.25372;
  guint8 * code.1043;
  guint8 * code.1044;
  unsigned char D.25375;
  guint8 * code.1045;
  guint8 * code.1046;
  guint8 * code.1047;
  guint8 * code.1048;
  guint8 * code.1049;
  guint8 * code.1050;
  guint8 * code.1051;
  guint8 * code.1052;
  guint8 * code.1053;
  guint8 * code.1054;
  guint8 * code.1055;
  guint8 * code.1056;
  guint8 * code.1057;
  guint8 * code.1058;
  unsigned char D.25399;
  guint8 * code.1059;
  guint8 * code.1060;
  unsigned char D.25402;
  guint8 * code.1061;
  guint8 * code.1062;
  unsigned char D.25405;
  guint8 * code.1063;
  guint8 * code.1064;
  unsigned char D.25408;
  guint8 * code.1065;
  guint8 * code.1066;
  guint8 * code.1067;
  guint8 * code.1068;
  guint8 * code.1069;
  guint8 * code.1070;
  guint8 * code.1071;
  guint8 * code.1072;
  unsigned char D.25422;
  guint8 * code.1073;
  guint8 * code.1074;
  unsigned char D.25425;
  guint8 * code.1075;
  guint8 * code.1076;
  unsigned char D.25428;
  guint8 * code.1077;
  guint8 * code.1078;
  unsigned char D.25431;
  guint8 * code.1079;
  guint8 * code.1080;
  unsigned char D.25436;
  guint8 * code.1081;
  guint8 * code.1082;
  guint8 * code.1083;
  guint8 * code.1084;
  guint8 * code.1085;
  guint8 * code.1086;
  unsigned char D.25449;
  guint8 * code.1087;
  guint8 * code.1088;
  guint8 * code.1089;
  guint8 * code.1090;
  guint8 * code.1091;
  guint8 * code.1092;
  unsigned char D.25461;
  guint8 * code.1093;
  guint8 * code.1094;
  guint8 * code.1095;
  guint8 * code.1096;
  unsigned char D.25466;
  guint8 * code.1097;
  guint8 * code.1098;
  unsigned char D.25469;
  guint8 * code.1099;
  guint8 * code.1100;
  unsigned char D.25472;
  guint8 * code.1101;
  guint8 * code.1102;
  unsigned char D.25475;
  guint8 * code.1103;
  guint8 * code.1104;
  unsigned char D.25481;
  guint8 * code.1105;
  guint8 * code.1106;
  guint8 * code.1107;
  guint8 * code.1108;
  guint8 * code.1109;
  guint8 * code.1110;
  unsigned char D.25488;
  guint8 * code.1111;
  guint8 * code.1112;
  unsigned char D.25491;
  guint8 * code.1113;
  guint8 * code.1114;
  unsigned char D.25494;
  guint8 * code.1115;
  guint8 * code.1116;
  unsigned char D.25497;
  guint8 * code.1117;
  guint8 * code.1118;
  unsigned char D.25502;
  guint8 * code.1119;
  guint8 * code.1120;
  guint8 * code.1121;
  guint8 * code.1122;
  unsigned char D.25511;
  guint8 * code.1123;
  guint8 * code.1124;
  unsigned char D.25514;
  guint8 * code.1125;
  guint8 * code.1126;
  guint8 * code.1127;
  guint8 * code.1128;
  long int code.1129;
  long int start.1130;
  long int D.25521;
  _Bool D.25522;
  long int D.25523;
  long int D.25524;
  int D.25527;
  unsigned int D.25530;
  struct MonoTrampInfo * D.25531;
  void * D.25532;
  guint8 * start;
  int i;
  guint8 * code;
  guint32 pos;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  const guint kMaxCodeSize;
  static const char __PRETTY_FUNCTION__[26] = "mono_arch_get_call_filter";

  try
    {
      ji = 0B;
      unwind_ops = 0B;
      kMaxCodeSize = 128;
      kMaxCodeSize.708 = (int) kMaxCodeSize;
      code.709 = mono_global_codeman_reserve (kMaxCodeSize.708);
      code = code.709;
      code.710 = code;
      start = code.710;
      start.711 = start;
      code = start.711;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.24819>; else goto <D.24820>;
        <D.24819>:
        code.710 = code;
        code.712 = code.710;
        code.713 = code.712 + 1;
        code = code.713;
        D.24823 = _amd64_rex_bits | 64;
        *code.712 = D.24823;
        <D.24820>:
      }
      code.710 = code;
      code.714 = code.710;
      code.715 = code.714 + 1;
      code = code.715;
      *code.714 = 85;
      if (0 != 0) goto <D.24826>; else goto <D.24827>;
      <D.24826>:
      code.710 = code;
      code.716 = code.710;
      code.717 = code.716 + 1;
      code = code.717;
      *code.716 = 102;
      <D.24827>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.24830>; else goto <D.24831>;
        <D.24830>:
        code.710 = code;
        code.718 = code.710;
        code.719 = code.718 + 1;
        code = code.719;
        D.24834 = _amd64_rex_bits | 64;
        *code.718 = D.24834;
        <D.24831>:
      }
      switch (8) <default: <D.22947>, case 1: <D.22942>, case 2: <D.22944>, case 4: <D.22945>, case 8: <D.22946>>
      <D.22942>:
      code.710 = code;
      code.720 = code.710;
      code.721 = code.720 + 1;
      code = code.721;
      *code.720 = 138;
      goto <D.22943>;
      <D.22944>:
      <D.22945>:
      <D.22946>:
      code.710 = code;
      code.722 = code.710;
      code.723 = code.722 + 1;
      code = code.723;
      *code.722 = 139;
      goto <D.22943>;
      <D.22947>:
      __assert_fail ("0", "exceptions-amd64.c", 277, &__PRETTY_FUNCTION__);
      <D.22943>:
      code.710 = code;
      code.724 = code.710;
      code.725 = code.724 + 1;
      code = code.725;
      *code.724 = 236;
      pos = 0;
      i = 0;
      goto <D.22951>;
      <D.22950>:
      D.24841 = 61480 >> i;
      D.24842 = D.24841 & 1;
      if (D.24842 != 0) goto <D.24843>; else goto <D.24844>;
      <D.24843>:
      {
        unsigned char _amd64_rex_bits;

        D.24845 = i > 7;
        _amd64_rex_bits = (unsigned char) D.24845;
        if (_amd64_rex_bits != 0) goto <D.24846>; else goto <D.24847>;
        <D.24846>:
        code.710 = code;
        code.726 = code.710;
        code.727 = code.726 + 1;
        code = code.727;
        D.24850 = _amd64_rex_bits | 64;
        *code.726 = D.24850;
        <D.24847>:
      }
      code.710 = code;
      code.728 = code.710;
      code.729 = code.728 + 1;
      code = code.729;
      D.24853 = (unsigned char) i;
      D.24854 = D.24853 & 7;
      D.24855 = D.24854 + 80;
      *code.728 = D.24855;
      pos = pos + 8;
      <D.24844>:
      i = i + 1;
      <D.22951>:
      if (i <= 16) goto <D.22950>; else goto <D.22952>;
      <D.22952>:
      pos = pos + 8;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.24856>; else goto <D.24857>;
        <D.24856>:
        code.710 = code;
        code.730 = code.710;
        code.731 = code.730 + 1;
        code = code.731;
        D.24860 = _amd64_rex_bits | 64;
        *code.730 = D.24860;
        <D.24857>:
      }
      code.710 = code;
      code.732 = code.710;
      code.733 = code.732 + 1;
      code = code.733;
      *code.732 = 85;
      D.24863 = pos & 8;
      if (D.24863 == 0) goto <D.24864>; else goto <D.24865>;
      <D.24864>:
      if (1 != 0) goto <D.24866>; else goto <D.24867>;
      <D.24866>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.24868>; else goto <D.24869>;
        <D.24868>:
        code.710 = code;
        code.734 = code.710;
        code.735 = code.734 + 1;
        code = code.735;
        D.24872 = _amd64_rex_bits | 64;
        *code.734 = D.24872;
        <D.24869>:
      }
      code.710 = code;
      code.736 = code.710;
      code.737 = code.736 + 1;
      code = code.737;
      *code.736 = 131;
      code.710 = code;
      code.738 = code.710;
      code.739 = code.738 + 1;
      code = code.739;
      *code.738 = 236;
      code.710 = code;
      *code.710 = 8;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.24878>;
      <D.24867>:
      if (0 != 0) goto <D.24879>; else goto <D.24880>;
      <D.24879>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.24881>; else goto <D.24882>;
        <D.24881>:
        code.710 = code;
        code.741 = code.710;
        code.742 = code.741 + 1;
        code = code.742;
        D.24885 = _amd64_rex_bits | 64;
        *code.741 = D.24885;
        <D.24882>:
      }
      code.710 = code;
      code.743 = code.710;
      code.744 = code.743 + 1;
      code = code.744;
      *code.743 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.745 = code.710;
            code.746 = code.745 + 1;
            code = code.746;
            D.24890 = imb.b[0];
            *code.745 = D.24890;
            code.710 = code;
            code.747 = code.710;
            code.748 = code.747 + 1;
            code = code.748;
            D.24893 = imb.b[1];
            *code.747 = D.24893;
            code.710 = code;
            code.749 = code.710;
            code.750 = code.749 + 1;
            code = code.750;
            D.24896 = imb.b[2];
            *code.749 = D.24896;
            code.710 = code;
            code.751 = code.710;
            code.752 = code.751 + 1;
            code = code.752;
            D.24899 = imb.b[3];
            *code.751 = D.24899;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24900>;
      <D.24880>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.24901>; else goto <D.24902>;
        <D.24901>:
        code.710 = code;
        code.753 = code.710;
        code.754 = code.753 + 1;
        code = code.754;
        D.24905 = _amd64_rex_bits | 64;
        *code.753 = D.24905;
        <D.24902>:
      }
      code.710 = code;
      code.755 = code.710;
      code.756 = code.755 + 1;
      code = code.756;
      *code.755 = 129;
      code.710 = code;
      code.757 = code.710;
      code.758 = code.757 + 1;
      code = code.758;
      *code.757 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.759 = code.710;
            code.760 = code.759 + 1;
            code = code.760;
            D.24912 = imb.b[0];
            *code.759 = D.24912;
            code.710 = code;
            code.761 = code.710;
            code.762 = code.761 + 1;
            code = code.762;
            D.24915 = imb.b[1];
            *code.761 = D.24915;
            code.710 = code;
            code.763 = code.710;
            code.764 = code.763 + 1;
            code = code.764;
            D.24918 = imb.b[2];
            *code.763 = D.24918;
            code.710 = code;
            code.765 = code.710;
            code.766 = code.765 + 1;
            code = code.766;
            D.24921 = imb.b[3];
            *code.765 = D.24921;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24900>:
      <D.24878>:
      <D.24865>:
      if (0 != 0) goto <D.24922>; else goto <D.24923>;
      <D.24922>:
      code.710 = code;
      code.767 = code.710;
      code.768 = code.767 + 1;
      code = code.768;
      *code.767 = 102;
      <D.24923>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.24926>; else goto <D.24927>;
        <D.24926>:
        code.710 = code;
        code.769 = code.710;
        code.770 = code.769 + 1;
        code = code.770;
        D.24930 = _amd64_rex_bits | 64;
        *code.769 = D.24930;
        <D.24927>:
      }
      switch (8) <default: <D.22965>, case 1: <D.22960>, case 2: <D.22962>, case 4: <D.22963>, case 8: <D.22964>>
      <D.22960>:
      code.710 = code;
      code.771 = code.710;
      code.772 = code.771 + 1;
      code = code.772;
      *code.771 = 138;
      goto <D.22961>;
      <D.22962>:
      <D.22963>:
      <D.22964>:
      code.710 = code;
      code.773 = code.710;
      code.774 = code.773 + 1;
      code = code.774;
      *code.773 = 139;
      goto <D.22961>;
      <D.22965>:
      __assert_fail ("0", "exceptions-amd64.c", 296, &__PRETTY_FUNCTION__);
      <D.22961>:
      if (0 != 0) goto <D.24935>; else goto <D.24936>;
      <D.24935>:
      code.710 = code;
      code.775 = code.710;
      code.776 = code.775 + 1;
      code = code.776;
      *code.775 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.710 = code;
            code.777 = code.710;
            code.778 = code.777 + 1;
            code = code.778;
            D.24941 = imb.b[0];
            *code.777 = D.24941;
            code.710 = code;
            code.779 = code.710;
            code.780 = code.779 + 1;
            code = code.780;
            D.24944 = imb.b[1];
            *code.779 = D.24944;
            code.710 = code;
            code.781 = code.710;
            code.782 = code.781 + 1;
            code = code.782;
            D.24947 = imb.b[2];
            *code.781 = D.24947;
            code.710 = code;
            code.783 = code.710;
            code.784 = code.783 + 1;
            code = code.784;
            D.24950 = imb.b[3];
            *code.783 = D.24950;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.24951>;
      <D.24936>:
      if (0 != 0) goto <D.24952>; else goto <D.24953>;
      <D.24952>:
      if (0 != 0) goto <D.24954>; else goto <D.24955>;
      <D.24954>:
      code.710 = code;
      code.785 = code.710;
      code.786 = code.785 + 1;
      code = code.786;
      *code.785 = 44;
      code.710 = code;
      code.787 = code.710;
      code.788 = code.787 + 1;
      code = code.788;
      *code.787 = 36;
      goto <D.24960>;
      <D.24955>:
      if (1 != 0) goto <D.24961>; else goto <D.24962>;
      <D.24961>:
      code.710 = code;
      code.789 = code.710;
      code.790 = code.789 + 1;
      code = code.790;
      *code.789 = 108;
      code.710 = code;
      code.791 = code.710;
      code.792 = code.791 + 1;
      code = code.792;
      *code.791 = 36;
      code.710 = code;
      *code.710 = 32;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.24967>;
      <D.24962>:
      code.710 = code;
      code.793 = code.710;
      code.794 = code.793 + 1;
      code = code.794;
      *code.793 = 172;
      code.710 = code;
      code.795 = code.710;
      code.796 = code.795 + 1;
      code = code.796;
      *code.795 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.710 = code;
            code.797 = code.710;
            code.798 = code.797 + 1;
            code = code.798;
            D.24974 = imb.b[0];
            *code.797 = D.24974;
            code.710 = code;
            code.799 = code.710;
            code.800 = code.799 + 1;
            code = code.800;
            D.24977 = imb.b[1];
            *code.799 = D.24977;
            code.710 = code;
            code.801 = code.710;
            code.802 = code.801 + 1;
            code = code.802;
            D.24980 = imb.b[2];
            *code.801 = D.24980;
            code.710 = code;
            code.803 = code.710;
            code.804 = code.803 + 1;
            code = code.804;
            D.24983 = imb.b[3];
            *code.803 = D.24983;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24967>:
      <D.24960>:
      goto <D.22968>;
      <D.24953>:
      if (0 != 0) goto <D.24984>; else goto <D.24985>;
      <D.24984>:
      code.710 = code;
      code.805 = code.710;
      code.806 = code.805 + 1;
      code = code.806;
      *code.805 = 47;
      goto <D.22968>;
      <D.24985>:
      if (1 != 0) goto <D.24988>; else goto <D.24989>;
      <D.24988>:
      code.710 = code;
      code.807 = code.710;
      code.808 = code.807 + 1;
      code = code.808;
      *code.807 = 111;
      code.710 = code;
      *code.710 = 32;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.24992>;
      <D.24989>:
      code.710 = code;
      code.809 = code.710;
      code.810 = code.809 + 1;
      code = code.810;
      *code.809 = 175;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.710 = code;
            code.811 = code.710;
            code.812 = code.811 + 1;
            code = code.812;
            D.24997 = imb.b[0];
            *code.811 = D.24997;
            code.710 = code;
            code.813 = code.710;
            code.814 = code.813 + 1;
            code = code.814;
            D.25000 = imb.b[1];
            *code.813 = D.25000;
            code.710 = code;
            code.815 = code.710;
            code.816 = code.815 + 1;
            code = code.816;
            D.25003 = imb.b[2];
            *code.815 = D.25003;
            code.710 = code;
            code.817 = code.710;
            code.818 = code.817 + 1;
            code = code.818;
            D.25006 = imb.b[3];
            *code.817 = D.25006;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.24992>:
      <D.22968>:
      <D.24951>:
      if (0 != 0) goto <D.25007>; else goto <D.25008>;
      <D.25007>:
      code.710 = code;
      code.819 = code.710;
      code.820 = code.819 + 1;
      code = code.820;
      *code.819 = 102;
      <D.25008>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25011>; else goto <D.25012>;
        <D.25011>:
        code.710 = code;
        code.821 = code.710;
        code.822 = code.821 + 1;
        code = code.822;
        D.25015 = _amd64_rex_bits | 64;
        *code.821 = D.25015;
        <D.25012>:
      }
      switch (8) <default: <D.22976>, case 1: <D.22971>, case 2: <D.22973>, case 4: <D.22974>, case 8: <D.22975>>
      <D.22971>:
      code.710 = code;
      code.823 = code.710;
      code.824 = code.823 + 1;
      code = code.824;
      *code.823 = 138;
      goto <D.22972>;
      <D.22973>:
      <D.22974>:
      <D.22975>:
      code.710 = code;
      code.825 = code.710;
      code.826 = code.825 + 1;
      code = code.826;
      *code.825 = 139;
      goto <D.22972>;
      <D.22976>:
      __assert_fail ("0", "exceptions-amd64.c", 298, &__PRETTY_FUNCTION__);
      <D.22972>:
      if (0 != 0) goto <D.25020>; else goto <D.25021>;
      <D.25020>:
      code.710 = code;
      code.827 = code.710;
      code.828 = code.827 + 1;
      code = code.828;
      *code.827 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.829 = code.710;
            code.830 = code.829 + 1;
            code = code.830;
            D.25026 = imb.b[0];
            *code.829 = D.25026;
            code.710 = code;
            code.831 = code.710;
            code.832 = code.831 + 1;
            code = code.832;
            D.25029 = imb.b[1];
            *code.831 = D.25029;
            code.710 = code;
            code.833 = code.710;
            code.834 = code.833 + 1;
            code = code.834;
            D.25032 = imb.b[2];
            *code.833 = D.25032;
            code.710 = code;
            code.835 = code.710;
            code.836 = code.835 + 1;
            code = code.836;
            D.25035 = imb.b[3];
            *code.835 = D.25035;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25036>;
      <D.25021>:
      if (0 != 0) goto <D.25037>; else goto <D.25038>;
      <D.25037>:
      if (0 != 0) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      code.710 = code;
      code.837 = code.710;
      code.838 = code.837 + 1;
      code = code.838;
      *code.837 = 28;
      code.710 = code;
      code.839 = code.710;
      code.840 = code.839 + 1;
      code = code.840;
      *code.839 = 36;
      goto <D.25045>;
      <D.25040>:
      if (1 != 0) goto <D.25046>; else goto <D.25047>;
      <D.25046>:
      code.710 = code;
      code.841 = code.710;
      code.842 = code.841 + 1;
      code = code.842;
      *code.841 = 92;
      code.710 = code;
      code.843 = code.710;
      code.844 = code.843 + 1;
      code = code.844;
      *code.843 = 36;
      code.710 = code;
      *code.710 = 8;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25052>;
      <D.25047>:
      code.710 = code;
      code.845 = code.710;
      code.846 = code.845 + 1;
      code = code.846;
      *code.845 = 156;
      code.710 = code;
      code.847 = code.710;
      code.848 = code.847 + 1;
      code = code.848;
      *code.847 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.849 = code.710;
            code.850 = code.849 + 1;
            code = code.850;
            D.25059 = imb.b[0];
            *code.849 = D.25059;
            code.710 = code;
            code.851 = code.710;
            code.852 = code.851 + 1;
            code = code.852;
            D.25062 = imb.b[1];
            *code.851 = D.25062;
            code.710 = code;
            code.853 = code.710;
            code.854 = code.853 + 1;
            code = code.854;
            D.25065 = imb.b[2];
            *code.853 = D.25065;
            code.710 = code;
            code.855 = code.710;
            code.856 = code.855 + 1;
            code = code.856;
            D.25068 = imb.b[3];
            *code.855 = D.25068;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25052>:
      <D.25045>:
      goto <D.22979>;
      <D.25038>:
      if (0 != 0) goto <D.25069>; else goto <D.25070>;
      <D.25069>:
      code.710 = code;
      code.857 = code.710;
      code.858 = code.857 + 1;
      code = code.858;
      *code.857 = 31;
      goto <D.22979>;
      <D.25070>:
      if (1 != 0) goto <D.25073>; else goto <D.25074>;
      <D.25073>:
      code.710 = code;
      code.859 = code.710;
      code.860 = code.859 + 1;
      code = code.860;
      *code.859 = 95;
      code.710 = code;
      *code.710 = 8;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25077>;
      <D.25074>:
      code.710 = code;
      code.861 = code.710;
      code.862 = code.861 + 1;
      code = code.862;
      *code.861 = 159;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.863 = code.710;
            code.864 = code.863 + 1;
            code = code.864;
            D.25082 = imb.b[0];
            *code.863 = D.25082;
            code.710 = code;
            code.865 = code.710;
            code.866 = code.865 + 1;
            code = code.866;
            D.25085 = imb.b[1];
            *code.865 = D.25085;
            code.710 = code;
            code.867 = code.710;
            code.868 = code.867 + 1;
            code = code.868;
            D.25088 = imb.b[2];
            *code.867 = D.25088;
            code.710 = code;
            code.869 = code.710;
            code.870 = code.869 + 1;
            code = code.870;
            D.25091 = imb.b[3];
            *code.869 = D.25091;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25077>:
      <D.22979>:
      <D.25036>:
      if (0 != 0) goto <D.25092>; else goto <D.25093>;
      <D.25092>:
      code.710 = code;
      code.871 = code.710;
      code.872 = code.871 + 1;
      code = code.872;
      *code.871 = 102;
      <D.25093>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.25096>; else goto <D.25097>;
        <D.25096>:
        code.710 = code;
        code.873 = code.710;
        code.874 = code.873 + 1;
        code = code.874;
        D.25100 = _amd64_rex_bits | 64;
        *code.873 = D.25100;
        <D.25097>:
      }
      switch (8) <default: <D.22987>, case 1: <D.22982>, case 2: <D.22984>, case 4: <D.22985>, case 8: <D.22986>>
      <D.22982>:
      code.710 = code;
      code.875 = code.710;
      code.876 = code.875 + 1;
      code = code.876;
      *code.875 = 138;
      goto <D.22983>;
      <D.22984>:
      <D.22985>:
      <D.22986>:
      code.710 = code;
      code.877 = code.710;
      code.878 = code.877 + 1;
      code = code.878;
      *code.877 = 139;
      goto <D.22983>;
      <D.22987>:
      __assert_fail ("0", "exceptions-amd64.c", 299, &__PRETTY_FUNCTION__);
      <D.22983>:
      if (0 != 0) goto <D.25105>; else goto <D.25106>;
      <D.25105>:
      code.710 = code;
      code.879 = code.710;
      code.880 = code.879 + 1;
      code = code.880;
      *code.879 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.710 = code;
            code.881 = code.710;
            code.882 = code.881 + 1;
            code = code.882;
            D.25111 = imb.b[0];
            *code.881 = D.25111;
            code.710 = code;
            code.883 = code.710;
            code.884 = code.883 + 1;
            code = code.884;
            D.25114 = imb.b[1];
            *code.883 = D.25114;
            code.710 = code;
            code.885 = code.710;
            code.886 = code.885 + 1;
            code = code.886;
            D.25117 = imb.b[2];
            *code.885 = D.25117;
            code.710 = code;
            code.887 = code.710;
            code.888 = code.887 + 1;
            code = code.888;
            D.25120 = imb.b[3];
            *code.887 = D.25120;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25121>;
      <D.25106>:
      if (0 != 0) goto <D.25122>; else goto <D.25123>;
      <D.25122>:
      if (0 != 0) goto <D.25124>; else goto <D.25125>;
      <D.25124>:
      code.710 = code;
      code.889 = code.710;
      code.890 = code.889 + 1;
      code = code.890;
      *code.889 = 36;
      code.710 = code;
      code.891 = code.710;
      code.892 = code.891 + 1;
      code = code.892;
      *code.891 = 36;
      goto <D.25130>;
      <D.25125>:
      if (1 != 0) goto <D.25131>; else goto <D.25132>;
      <D.25131>:
      code.710 = code;
      code.893 = code.710;
      code.894 = code.893 + 1;
      code = code.894;
      *code.893 = 100;
      code.710 = code;
      code.895 = code.710;
      code.896 = code.895 + 1;
      code = code.896;
      *code.895 = 36;
      code.710 = code;
      *code.710 = 96;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25137>;
      <D.25132>:
      code.710 = code;
      code.897 = code.710;
      code.898 = code.897 + 1;
      code = code.898;
      *code.897 = 164;
      code.710 = code;
      code.899 = code.710;
      code.900 = code.899 + 1;
      code = code.900;
      *code.899 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.710 = code;
            code.901 = code.710;
            code.902 = code.901 + 1;
            code = code.902;
            D.25144 = imb.b[0];
            *code.901 = D.25144;
            code.710 = code;
            code.903 = code.710;
            code.904 = code.903 + 1;
            code = code.904;
            D.25147 = imb.b[1];
            *code.903 = D.25147;
            code.710 = code;
            code.905 = code.710;
            code.906 = code.905 + 1;
            code = code.906;
            D.25150 = imb.b[2];
            *code.905 = D.25150;
            code.710 = code;
            code.907 = code.710;
            code.908 = code.907 + 1;
            code = code.908;
            D.25153 = imb.b[3];
            *code.907 = D.25153;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25137>:
      <D.25130>:
      goto <D.22990>;
      <D.25123>:
      if (0 != 0) goto <D.25154>; else goto <D.25155>;
      <D.25154>:
      code.710 = code;
      code.909 = code.710;
      code.910 = code.909 + 1;
      code = code.910;
      *code.909 = 39;
      goto <D.22990>;
      <D.25155>:
      if (1 != 0) goto <D.25158>; else goto <D.25159>;
      <D.25158>:
      code.710 = code;
      code.911 = code.710;
      code.912 = code.911 + 1;
      code = code.912;
      *code.911 = 103;
      code.710 = code;
      *code.710 = 96;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25162>;
      <D.25159>:
      code.710 = code;
      code.913 = code.710;
      code.914 = code.913 + 1;
      code = code.914;
      *code.913 = 167;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 96;
            code.710 = code;
            code.915 = code.710;
            code.916 = code.915 + 1;
            code = code.916;
            D.25167 = imb.b[0];
            *code.915 = D.25167;
            code.710 = code;
            code.917 = code.710;
            code.918 = code.917 + 1;
            code = code.918;
            D.25170 = imb.b[1];
            *code.917 = D.25170;
            code.710 = code;
            code.919 = code.710;
            code.920 = code.919 + 1;
            code = code.920;
            D.25173 = imb.b[2];
            *code.919 = D.25173;
            code.710 = code;
            code.921 = code.710;
            code.922 = code.921 + 1;
            code = code.922;
            D.25176 = imb.b[3];
            *code.921 = D.25176;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25162>:
      <D.22990>:
      <D.25121>:
      if (0 != 0) goto <D.25177>; else goto <D.25178>;
      <D.25177>:
      code.710 = code;
      code.923 = code.710;
      code.924 = code.923 + 1;
      code = code.924;
      *code.923 = 102;
      <D.25178>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.25181>; else goto <D.25182>;
        <D.25181>:
        code.710 = code;
        code.925 = code.710;
        code.926 = code.925 + 1;
        code = code.926;
        D.25185 = _amd64_rex_bits | 64;
        *code.925 = D.25185;
        <D.25182>:
      }
      switch (8) <default: <D.22998>, case 1: <D.22993>, case 2: <D.22995>, case 4: <D.22996>, case 8: <D.22997>>
      <D.22993>:
      code.710 = code;
      code.927 = code.710;
      code.928 = code.927 + 1;
      code = code.928;
      *code.927 = 138;
      goto <D.22994>;
      <D.22995>:
      <D.22996>:
      <D.22997>:
      code.710 = code;
      code.929 = code.710;
      code.930 = code.929 + 1;
      code = code.930;
      *code.929 = 139;
      goto <D.22994>;
      <D.22998>:
      __assert_fail ("0", "exceptions-amd64.c", 300, &__PRETTY_FUNCTION__);
      <D.22994>:
      if (0 != 0) goto <D.25190>; else goto <D.25191>;
      <D.25190>:
      code.710 = code;
      code.931 = code.710;
      code.932 = code.931 + 1;
      code = code.932;
      *code.931 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.710 = code;
            code.933 = code.710;
            code.934 = code.933 + 1;
            code = code.934;
            D.25196 = imb.b[0];
            *code.933 = D.25196;
            code.710 = code;
            code.935 = code.710;
            code.936 = code.935 + 1;
            code = code.936;
            D.25199 = imb.b[1];
            *code.935 = D.25199;
            code.710 = code;
            code.937 = code.710;
            code.938 = code.937 + 1;
            code = code.938;
            D.25202 = imb.b[2];
            *code.937 = D.25202;
            code.710 = code;
            code.939 = code.710;
            code.940 = code.939 + 1;
            code = code.940;
            D.25205 = imb.b[3];
            *code.939 = D.25205;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25206>;
      <D.25191>:
      if (0 != 0) goto <D.25207>; else goto <D.25208>;
      <D.25207>:
      if (0 != 0) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      code.710 = code;
      code.941 = code.710;
      code.942 = code.941 + 1;
      code = code.942;
      *code.941 = 44;
      code.710 = code;
      code.943 = code.710;
      code.944 = code.943 + 1;
      code = code.944;
      *code.943 = 36;
      goto <D.25215>;
      <D.25210>:
      if (1 != 0) goto <D.25216>; else goto <D.25217>;
      <D.25216>:
      code.710 = code;
      code.945 = code.710;
      code.946 = code.945 + 1;
      code = code.946;
      *code.945 = 108;
      code.710 = code;
      code.947 = code.710;
      code.948 = code.947 + 1;
      code = code.948;
      *code.947 = 36;
      code.710 = code;
      *code.710 = 104;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25222>;
      <D.25217>:
      code.710 = code;
      code.949 = code.710;
      code.950 = code.949 + 1;
      code = code.950;
      *code.949 = 172;
      code.710 = code;
      code.951 = code.710;
      code.952 = code.951 + 1;
      code = code.952;
      *code.951 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.710 = code;
            code.953 = code.710;
            code.954 = code.953 + 1;
            code = code.954;
            D.25229 = imb.b[0];
            *code.953 = D.25229;
            code.710 = code;
            code.955 = code.710;
            code.956 = code.955 + 1;
            code = code.956;
            D.25232 = imb.b[1];
            *code.955 = D.25232;
            code.710 = code;
            code.957 = code.710;
            code.958 = code.957 + 1;
            code = code.958;
            D.25235 = imb.b[2];
            *code.957 = D.25235;
            code.710 = code;
            code.959 = code.710;
            code.960 = code.959 + 1;
            code = code.960;
            D.25238 = imb.b[3];
            *code.959 = D.25238;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25222>:
      <D.25215>:
      goto <D.23001>;
      <D.25208>:
      if (0 != 0) goto <D.25239>; else goto <D.25240>;
      <D.25239>:
      code.710 = code;
      code.961 = code.710;
      code.962 = code.961 + 1;
      code = code.962;
      *code.961 = 47;
      goto <D.23001>;
      <D.25240>:
      if (1 != 0) goto <D.25243>; else goto <D.25244>;
      <D.25243>:
      code.710 = code;
      code.963 = code.710;
      code.964 = code.963 + 1;
      code = code.964;
      *code.963 = 111;
      code.710 = code;
      *code.710 = 104;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25247>;
      <D.25244>:
      code.710 = code;
      code.965 = code.710;
      code.966 = code.965 + 1;
      code = code.966;
      *code.965 = 175;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 104;
            code.710 = code;
            code.967 = code.710;
            code.968 = code.967 + 1;
            code = code.968;
            D.25252 = imb.b[0];
            *code.967 = D.25252;
            code.710 = code;
            code.969 = code.710;
            code.970 = code.969 + 1;
            code = code.970;
            D.25255 = imb.b[1];
            *code.969 = D.25255;
            code.710 = code;
            code.971 = code.710;
            code.972 = code.971 + 1;
            code = code.972;
            D.25258 = imb.b[2];
            *code.971 = D.25258;
            code.710 = code;
            code.973 = code.710;
            code.974 = code.973 + 1;
            code = code.974;
            D.25261 = imb.b[3];
            *code.973 = D.25261;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25247>:
      <D.23001>:
      <D.25206>:
      if (0 != 0) goto <D.25262>; else goto <D.25263>;
      <D.25262>:
      code.710 = code;
      code.975 = code.710;
      code.976 = code.975 + 1;
      code = code.976;
      *code.975 = 102;
      <D.25263>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.25266>; else goto <D.25267>;
        <D.25266>:
        code.710 = code;
        code.977 = code.710;
        code.978 = code.977 + 1;
        code = code.978;
        D.25270 = _amd64_rex_bits | 64;
        *code.977 = D.25270;
        <D.25267>:
      }
      switch (8) <default: <D.23009>, case 1: <D.23004>, case 2: <D.23006>, case 4: <D.23007>, case 8: <D.23008>>
      <D.23004>:
      code.710 = code;
      code.979 = code.710;
      code.980 = code.979 + 1;
      code = code.980;
      *code.979 = 138;
      goto <D.23005>;
      <D.23006>:
      <D.23007>:
      <D.23008>:
      code.710 = code;
      code.981 = code.710;
      code.982 = code.981 + 1;
      code = code.982;
      *code.981 = 139;
      goto <D.23005>;
      <D.23009>:
      __assert_fail ("0", "exceptions-amd64.c", 301, &__PRETTY_FUNCTION__);
      <D.23005>:
      if (0 != 0) goto <D.25275>; else goto <D.25276>;
      <D.25275>:
      code.710 = code;
      code.983 = code.710;
      code.984 = code.983 + 1;
      code = code.984;
      *code.983 = 53;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.710 = code;
            code.985 = code.710;
            code.986 = code.985 + 1;
            code = code.986;
            D.25281 = imb.b[0];
            *code.985 = D.25281;
            code.710 = code;
            code.987 = code.710;
            code.988 = code.987 + 1;
            code = code.988;
            D.25284 = imb.b[1];
            *code.987 = D.25284;
            code.710 = code;
            code.989 = code.710;
            code.990 = code.989 + 1;
            code = code.990;
            D.25287 = imb.b[2];
            *code.989 = D.25287;
            code.710 = code;
            code.991 = code.710;
            code.992 = code.991 + 1;
            code = code.992;
            D.25290 = imb.b[3];
            *code.991 = D.25290;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25291>;
      <D.25276>:
      if (0 != 0) goto <D.25292>; else goto <D.25293>;
      <D.25292>:
      if (0 != 0) goto <D.25294>; else goto <D.25295>;
      <D.25294>:
      code.710 = code;
      code.993 = code.710;
      code.994 = code.993 + 1;
      code = code.994;
      *code.993 = 52;
      code.710 = code;
      code.995 = code.710;
      code.996 = code.995 + 1;
      code = code.996;
      *code.995 = 36;
      goto <D.25300>;
      <D.25295>:
      if (1 != 0) goto <D.25301>; else goto <D.25302>;
      <D.25301>:
      code.710 = code;
      code.997 = code.710;
      code.998 = code.997 + 1;
      code = code.998;
      *code.997 = 116;
      code.710 = code;
      code.999 = code.710;
      code.1000 = code.999 + 1;
      code = code.1000;
      *code.999 = 36;
      code.710 = code;
      *code.710 = 112;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25307>;
      <D.25302>:
      code.710 = code;
      code.1001 = code.710;
      code.1002 = code.1001 + 1;
      code = code.1002;
      *code.1001 = 180;
      code.710 = code;
      code.1003 = code.710;
      code.1004 = code.1003 + 1;
      code = code.1004;
      *code.1003 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.710 = code;
            code.1005 = code.710;
            code.1006 = code.1005 + 1;
            code = code.1006;
            D.25314 = imb.b[0];
            *code.1005 = D.25314;
            code.710 = code;
            code.1007 = code.710;
            code.1008 = code.1007 + 1;
            code = code.1008;
            D.25317 = imb.b[1];
            *code.1007 = D.25317;
            code.710 = code;
            code.1009 = code.710;
            code.1010 = code.1009 + 1;
            code = code.1010;
            D.25320 = imb.b[2];
            *code.1009 = D.25320;
            code.710 = code;
            code.1011 = code.710;
            code.1012 = code.1011 + 1;
            code = code.1012;
            D.25323 = imb.b[3];
            *code.1011 = D.25323;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25307>:
      <D.25300>:
      goto <D.23012>;
      <D.25293>:
      if (0 != 0) goto <D.25324>; else goto <D.25325>;
      <D.25324>:
      code.710 = code;
      code.1013 = code.710;
      code.1014 = code.1013 + 1;
      code = code.1014;
      *code.1013 = 55;
      goto <D.23012>;
      <D.25325>:
      if (1 != 0) goto <D.25328>; else goto <D.25329>;
      <D.25328>:
      code.710 = code;
      code.1015 = code.710;
      code.1016 = code.1015 + 1;
      code = code.1016;
      *code.1015 = 119;
      code.710 = code;
      *code.710 = 112;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25332>;
      <D.25329>:
      code.710 = code;
      code.1017 = code.710;
      code.1018 = code.1017 + 1;
      code = code.1018;
      *code.1017 = 183;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 112;
            code.710 = code;
            code.1019 = code.710;
            code.1020 = code.1019 + 1;
            code = code.1020;
            D.25337 = imb.b[0];
            *code.1019 = D.25337;
            code.710 = code;
            code.1021 = code.710;
            code.1022 = code.1021 + 1;
            code = code.1022;
            D.25340 = imb.b[1];
            *code.1021 = D.25340;
            code.710 = code;
            code.1023 = code.710;
            code.1024 = code.1023 + 1;
            code = code.1024;
            D.25343 = imb.b[2];
            *code.1023 = D.25343;
            code.710 = code;
            code.1025 = code.710;
            code.1026 = code.1025 + 1;
            code = code.1026;
            D.25346 = imb.b[3];
            *code.1025 = D.25346;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25332>:
      <D.23012>:
      <D.25291>:
      if (0 != 0) goto <D.25347>; else goto <D.25348>;
      <D.25347>:
      code.710 = code;
      code.1027 = code.710;
      code.1028 = code.1027 + 1;
      code = code.1028;
      *code.1027 = 102;
      <D.25348>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.25351>; else goto <D.25352>;
        <D.25351>:
        code.710 = code;
        code.1029 = code.710;
        code.1030 = code.1029 + 1;
        code = code.1030;
        D.25355 = _amd64_rex_bits | 64;
        *code.1029 = D.25355;
        <D.25352>:
      }
      switch (8) <default: <D.23020>, case 1: <D.23015>, case 2: <D.23017>, case 4: <D.23018>, case 8: <D.23019>>
      <D.23015>:
      code.710 = code;
      code.1031 = code.710;
      code.1032 = code.1031 + 1;
      code = code.1032;
      *code.1031 = 138;
      goto <D.23016>;
      <D.23017>:
      <D.23018>:
      <D.23019>:
      code.710 = code;
      code.1033 = code.710;
      code.1034 = code.1033 + 1;
      code = code.1034;
      *code.1033 = 139;
      goto <D.23016>;
      <D.23020>:
      __assert_fail ("0", "exceptions-amd64.c", 303, &__PRETTY_FUNCTION__);
      <D.23016>:
      if (0 != 0) goto <D.25360>; else goto <D.25361>;
      <D.25360>:
      code.710 = code;
      code.1035 = code.710;
      code.1036 = code.1035 + 1;
      code = code.1036;
      *code.1035 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.710 = code;
            code.1037 = code.710;
            code.1038 = code.1037 + 1;
            code = code.1038;
            D.25366 = imb.b[0];
            *code.1037 = D.25366;
            code.710 = code;
            code.1039 = code.710;
            code.1040 = code.1039 + 1;
            code = code.1040;
            D.25369 = imb.b[1];
            *code.1039 = D.25369;
            code.710 = code;
            code.1041 = code.710;
            code.1042 = code.1041 + 1;
            code = code.1042;
            D.25372 = imb.b[2];
            *code.1041 = D.25372;
            code.710 = code;
            code.1043 = code.710;
            code.1044 = code.1043 + 1;
            code = code.1044;
            D.25375 = imb.b[3];
            *code.1043 = D.25375;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25376>;
      <D.25361>:
      if (0 != 0) goto <D.25377>; else goto <D.25378>;
      <D.25377>:
      if (0 != 0) goto <D.25379>; else goto <D.25380>;
      <D.25379>:
      code.710 = code;
      code.1045 = code.710;
      code.1046 = code.1045 + 1;
      code = code.1046;
      *code.1045 = 60;
      code.710 = code;
      code.1047 = code.710;
      code.1048 = code.1047 + 1;
      code = code.1048;
      *code.1047 = 36;
      goto <D.25385>;
      <D.25380>:
      if (1 != 0) goto <D.25386>; else goto <D.25387>;
      <D.25386>:
      code.710 = code;
      code.1049 = code.710;
      code.1050 = code.1049 + 1;
      code = code.1050;
      *code.1049 = 124;
      code.710 = code;
      code.1051 = code.710;
      code.1052 = code.1051 + 1;
      code = code.1052;
      *code.1051 = 36;
      code.710 = code;
      *code.710 = 120;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25392>;
      <D.25387>:
      code.710 = code;
      code.1053 = code.710;
      code.1054 = code.1053 + 1;
      code = code.1054;
      *code.1053 = 188;
      code.710 = code;
      code.1055 = code.710;
      code.1056 = code.1055 + 1;
      code = code.1056;
      *code.1055 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.710 = code;
            code.1057 = code.710;
            code.1058 = code.1057 + 1;
            code = code.1058;
            D.25399 = imb.b[0];
            *code.1057 = D.25399;
            code.710 = code;
            code.1059 = code.710;
            code.1060 = code.1059 + 1;
            code = code.1060;
            D.25402 = imb.b[1];
            *code.1059 = D.25402;
            code.710 = code;
            code.1061 = code.710;
            code.1062 = code.1061 + 1;
            code = code.1062;
            D.25405 = imb.b[2];
            *code.1061 = D.25405;
            code.710 = code;
            code.1063 = code.710;
            code.1064 = code.1063 + 1;
            code = code.1064;
            D.25408 = imb.b[3];
            *code.1063 = D.25408;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25392>:
      <D.25385>:
      goto <D.23023>;
      <D.25378>:
      if (0 != 0) goto <D.25409>; else goto <D.25410>;
      <D.25409>:
      code.710 = code;
      code.1065 = code.710;
      code.1066 = code.1065 + 1;
      code = code.1066;
      *code.1065 = 63;
      goto <D.23023>;
      <D.25410>:
      if (1 != 0) goto <D.25413>; else goto <D.25414>;
      <D.25413>:
      code.710 = code;
      code.1067 = code.710;
      code.1068 = code.1067 + 1;
      code = code.1068;
      *code.1067 = 127;
      code.710 = code;
      *code.710 = 120;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25417>;
      <D.25414>:
      code.710 = code;
      code.1069 = code.710;
      code.1070 = code.1069 + 1;
      code = code.1070;
      *code.1069 = 191;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 120;
            code.710 = code;
            code.1071 = code.710;
            code.1072 = code.1071 + 1;
            code = code.1072;
            D.25422 = imb.b[0];
            *code.1071 = D.25422;
            code.710 = code;
            code.1073 = code.710;
            code.1074 = code.1073 + 1;
            code = code.1074;
            D.25425 = imb.b[1];
            *code.1073 = D.25425;
            code.710 = code;
            code.1075 = code.710;
            code.1076 = code.1075 + 1;
            code = code.1076;
            D.25428 = imb.b[2];
            *code.1075 = D.25428;
            code.710 = code;
            code.1077 = code.710;
            code.1078 = code.1077 + 1;
            code = code.1078;
            D.25431 = imb.b[3];
            *code.1077 = D.25431;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25417>:
      <D.23023>:
      <D.25376>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.25432>; else goto <D.25433>;
        <D.25432>:
        code.710 = code;
        code.1079 = code.710;
        code.1080 = code.1079 + 1;
        code = code.1080;
        D.25436 = _amd64_rex_bits | 64;
        *code.1079 = D.25436;
        <D.25433>:
      }
      code.710 = code;
      code.1081 = code.710;
      code.1082 = code.1081 + 1;
      code = code.1082;
      *code.1081 = 255;
      code.710 = code;
      code.1083 = code.710;
      code.1084 = code.1083 + 1;
      code = code.1084;
      *code.1083 = 214;
      D.24863 = pos & 8;
      if (D.24863 == 0) goto <D.25441>; else goto <D.25442>;
      <D.25441>:
      if (1 != 0) goto <D.25443>; else goto <D.25444>;
      <D.25443>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25445>; else goto <D.25446>;
        <D.25445>:
        code.710 = code;
        code.1085 = code.710;
        code.1086 = code.1085 + 1;
        code = code.1086;
        D.25449 = _amd64_rex_bits | 64;
        *code.1085 = D.25449;
        <D.25446>:
      }
      code.710 = code;
      code.1087 = code.710;
      code.1088 = code.1087 + 1;
      code = code.1088;
      *code.1087 = 131;
      code.710 = code;
      code.1089 = code.710;
      code.1090 = code.1089 + 1;
      code = code.1090;
      *code.1089 = 196;
      code.710 = code;
      *code.710 = 8;
      code.710 = code;
      code.740 = code.710 + 1;
      code = code.740;
      goto <D.25454>;
      <D.25444>:
      if (0 != 0) goto <D.25455>; else goto <D.25456>;
      <D.25455>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25457>; else goto <D.25458>;
        <D.25457>:
        code.710 = code;
        code.1091 = code.710;
        code.1092 = code.1091 + 1;
        code = code.1092;
        D.25461 = _amd64_rex_bits | 64;
        *code.1091 = D.25461;
        <D.25458>:
      }
      code.710 = code;
      code.1093 = code.710;
      code.1094 = code.1093 + 1;
      code = code.1094;
      *code.1093 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.1095 = code.710;
            code.1096 = code.1095 + 1;
            code = code.1096;
            D.25466 = imb.b[0];
            *code.1095 = D.25466;
            code.710 = code;
            code.1097 = code.710;
            code.1098 = code.1097 + 1;
            code = code.1098;
            D.25469 = imb.b[1];
            *code.1097 = D.25469;
            code.710 = code;
            code.1099 = code.710;
            code.1100 = code.1099 + 1;
            code = code.1100;
            D.25472 = imb.b[2];
            *code.1099 = D.25472;
            code.710 = code;
            code.1101 = code.710;
            code.1102 = code.1101 + 1;
            code = code.1102;
            D.25475 = imb.b[3];
            *code.1101 = D.25475;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25476>;
      <D.25456>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25477>; else goto <D.25478>;
        <D.25477>:
        code.710 = code;
        code.1103 = code.710;
        code.1104 = code.1103 + 1;
        code = code.1104;
        D.25481 = _amd64_rex_bits | 64;
        *code.1103 = D.25481;
        <D.25478>:
      }
      code.710 = code;
      code.1105 = code.710;
      code.1106 = code.1105 + 1;
      code = code.1106;
      *code.1105 = 129;
      code.710 = code;
      code.1107 = code.710;
      code.1108 = code.1107 + 1;
      code = code.1108;
      *code.1107 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.710 = code;
            code.1109 = code.710;
            code.1110 = code.1109 + 1;
            code = code.1110;
            D.25488 = imb.b[0];
            *code.1109 = D.25488;
            code.710 = code;
            code.1111 = code.710;
            code.1112 = code.1111 + 1;
            code = code.1112;
            D.25491 = imb.b[1];
            *code.1111 = D.25491;
            code.710 = code;
            code.1113 = code.710;
            code.1114 = code.1113 + 1;
            code = code.1114;
            D.25494 = imb.b[2];
            *code.1113 = D.25494;
            code.710 = code;
            code.1115 = code.710;
            code.1116 = code.1115 + 1;
            code = code.1116;
            D.25497 = imb.b[3];
            *code.1115 = D.25497;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25476>:
      <D.25454>:
      <D.25442>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.25498>; else goto <D.25499>;
        <D.25498>:
        code.710 = code;
        code.1117 = code.710;
        code.1118 = code.1117 + 1;
        code = code.1118;
        D.25502 = _amd64_rex_bits | 64;
        *code.1117 = D.25502;
        <D.25499>:
      }
      code.710 = code;
      code.1119 = code.710;
      code.1120 = code.1119 + 1;
      code = code.1120;
      *code.1119 = 93;
      i = 17;
      goto <D.23034>;
      <D.23033>:
      D.24841 = 61480 >> i;
      D.24842 = D.24841 & 1;
      if (D.24842 != 0) goto <D.25505>; else goto <D.25506>;
      <D.25505>:
      {
        unsigned char _amd64_rex_bits;

        D.24845 = i > 7;
        _amd64_rex_bits = (unsigned char) D.24845;
        if (_amd64_rex_bits != 0) goto <D.25507>; else goto <D.25508>;
        <D.25507>:
        code.710 = code;
        code.1121 = code.710;
        code.1122 = code.1121 + 1;
        code = code.1122;
        D.25511 = _amd64_rex_bits | 64;
        *code.1121 = D.25511;
        <D.25508>:
      }
      code.710 = code;
      code.1123 = code.710;
      code.1124 = code.1123 + 1;
      code = code.1124;
      D.24853 = (unsigned char) i;
      D.24854 = D.24853 & 7;
      D.25514 = D.24854 + 88;
      *code.1123 = D.25514;
      <D.25506>:
      i = i + -1;
      <D.23034>:
      if (i >= 0) goto <D.23033>; else goto <D.23035>;
      <D.23035>:
      code.710 = code;
      code.1125 = code.710;
      code.1126 = code.1125 + 1;
      code = code.1126;
      *code.1125 = 201;
      code.710 = code;
      code.1127 = code.710;
      code.1128 = code.1127 + 1;
      code = code.1128;
      *code.1127 = 195;
      code.710 = code;
      code.1129 = (long int) code.710;
      start.711 = start;
      start.1130 = (long int) start.711;
      D.25521 = code.1129 - start.1130;
      D.25522 = D.25521 > 127;
      D.25523 = (long int) D.25522;
      D.25524 = __builtin_expect (D.25523, 0);
      if (D.25524 != 0) goto <D.25525>; else goto <D.25526>;
      <D.25525>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 327, "(code - start) < kMaxCodeSize");
      <D.25526>:
      kMaxCodeSize.708 = (int) kMaxCodeSize;
      nacl_global_codeman_validate (&start, kMaxCodeSize.708, &code);
      code.710 = code;
      code.1129 = (long int) code.710;
      start.711 = start;
      start.1130 = (long int) start.711;
      D.25521 = code.1129 - start.1130;
      D.25527 = (int) D.25521;
      start.711 = start;
      mono_arch_flush_icache (start.711, D.25527);
      if (info != 0B) goto <D.25528>; else goto <D.25529>;
      <D.25528>:
      code.710 = code;
      code.1129 = (long int) code.710;
      start.711 = start;
      start.1130 = (long int) start.711;
      D.25521 = code.1129 - start.1130;
      D.25530 = (unsigned int) D.25521;
      start.711 = start;
      D.25531 = mono_tramp_info_create ("call_filter", start.711, D.25530, ji, unwind_ops);
      *info = D.25531;
      <D.25529>:
      D.25532 = start;
      return D.25532;
    }
  finally
    {
      start = {CLOBBER};
      code = {CLOBBER};
    }
}


mono_amd64_throw_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4, guint64 dummy5, guint64 dummy6, mgreg_t * regs, mgreg_t rip, struct MonoObject * exc, gboolean rethrow)
{
  long int D.25535;
  long int D.25536;
  long int D.25537;
  long int D.25538;
  long int D.25539;
  long int D.25540;
  long int D.25541;
  long int D.25542;
  long int D.25543;
  long int D.25544;
  long int D.25545;
  long int D.25546;
  struct MonoClass * D.25547;
  struct MonoObject * D.25548;
  long int D.25553;
  long int D.25554;
  struct MonoContext ctx;

  try
    {
      D.25535 = MEM[(mgreg_t *)regs + 32B];
      ctx.rsp = D.25535;
      ctx.rip = rip;
      D.25536 = MEM[(mgreg_t *)regs + 24B];
      ctx.rbx = D.25536;
      D.25537 = MEM[(mgreg_t *)regs + 40B];
      ctx.rbp = D.25537;
      D.25538 = MEM[(mgreg_t *)regs + 96B];
      ctx.r12 = D.25538;
      D.25539 = MEM[(mgreg_t *)regs + 104B];
      ctx.r13 = D.25539;
      D.25540 = MEM[(mgreg_t *)regs + 112B];
      ctx.r14 = D.25540;
      D.25541 = MEM[(mgreg_t *)regs + 120B];
      ctx.r15 = D.25541;
      D.25542 = MEM[(mgreg_t *)regs + 56B];
      ctx.rdi = D.25542;
      D.25543 = MEM[(mgreg_t *)regs + 48B];
      ctx.rsi = D.25543;
      D.25544 = *regs;
      ctx.rax = D.25544;
      D.25545 = MEM[(mgreg_t *)regs + 8B];
      ctx.rcx = D.25545;
      D.25546 = MEM[(mgreg_t *)regs + 16B];
      ctx.rdx = D.25546;
      D.25547 = mono_defaults.exception_class;
      D.25548 = mono_object_isinst (exc, D.25547);
      if (D.25548 != 0B) goto <D.25549>; else goto <D.25550>;
      <D.25549>:
      {
        struct MonoException * mono_ex;

        mono_ex = exc;
        if (rethrow == 0) goto <D.25551>; else goto <D.25552>;
        <D.25551>:
        mono_ex->stack_trace = 0B;
        <D.25552>:
      }
      <D.25550>:
      D.25553 = ctx.rip;
      D.25554 = D.25553 + -1;
      ctx.rip = D.25554;
      mono_handle_exception (&ctx, exc);
      mono_restore_context (&ctx);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "exceptions-amd64.c", 376);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_amd64_throw_corlib_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4, guint64 dummy5, guint64 dummy6, mgreg_t * regs, mgreg_t rip, guint32 ex_token_index, gint64 pc_offset)
{
  struct MonoClass * D.25555;
  struct MonoImage * D.25556;
  guint32 ex_token;
  struct MonoException * ex;

  ex_token = ex_token_index | 33554432;
  D.25555 = mono_defaults.exception_class;
  D.25556 = D.25555->image;
  ex = mono_exception_from_token (D.25556, ex_token);
  rip = rip - pc_offset;
  rip = rip + 1;
  mono_amd64_throw_exception (dummy1, dummy2, dummy3, dummy4, dummy5, dummy6, regs, rip, ex, 0);
}


mono_arch_get_throw_exception (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.25557;

  D.25557 = get_throw_trampoline (info, 0, 0, 0, 0, "throw_exception", aot);
  return D.25557;
}


get_throw_trampoline (struct MonoTrampInfo * * info, gboolean rethrow, gboolean corlib, gboolean llvm_abs, gboolean resume_unwind, const char * tramp_name, gboolean aot)
{
  int kMaxCodeSize.1131;
  void * code.1132;
  guint8 * code.1133;
  guint8 * start.1134;
  unsigned int stack_size.1135;
  unsigned int D.25566;
  guint8 * code.1136;
  guint8 * code.1137;
  unsigned char D.25573;
  guint8 * code.1138;
  guint8 * code.1139;
  guint8 * code.1140;
  guint8 * code.1141;
  unsigned char D.25578;
  guint8 * code.1142;
  guint8 * code.1143;
  guint8 * code.1144;
  unsigned char D.25587;
  guint8 * code.1145;
  guint8 * code.1146;
  guint8 * code.1147;
  guint8 * code.1148;
  unsigned char D.25592;
  guint8 * code.1149;
  guint8 * code.1150;
  unsigned char D.25595;
  guint8 * code.1151;
  guint8 * code.1152;
  unsigned char D.25598;
  guint8 * code.1153;
  guint8 * code.1154;
  unsigned char D.25601;
  guint8 * code.1155;
  guint8 * code.1156;
  unsigned char D.25607;
  guint8 * code.1157;
  guint8 * code.1158;
  guint8 * code.1159;
  guint8 * code.1160;
  guint8 * code.1161;
  guint8 * code.1162;
  unsigned char D.25614;
  guint8 * code.1163;
  guint8 * code.1164;
  unsigned char D.25617;
  guint8 * code.1165;
  guint8 * code.1166;
  unsigned char D.25620;
  guint8 * code.1167;
  guint8 * code.1168;
  unsigned char D.25623;
  int D.25626;
  long int code.1169;
  long int start.1170;
  long int D.25629;
  int D.25630;
  struct MonoUnwindOp * D.25631;
  unsigned int dummy_stack_space.1171;
  unsigned int D.25633;
  int D.25634;
  unsigned int D.25635;
  int D.25636;
  unsigned int D.25637;
  int D.25638;
  unsigned int D.25639;
  guint8 * code.1172;
  guint8 * code.1173;
  unsigned char iftmp.1174;
  guint8 * code.1175;
  guint8 * code.1176;
  unsigned char D.25654;
  guint8 * code.1177;
  guint8 * code.1178;
  guint8 * code.1179;
  guint8 * code.1180;
  long unsigned int D.25661;
  long unsigned int D.25662;
  long unsigned int D.25663;
  long unsigned int D.25664;
  guint8 * code.1181;
  guint8 * code.1182;
  int D.25669;
  int D.25670;
  signed char D.25671;
  signed char D.25672;
  unsigned char D.25673;
  guint8 * code.1183;
  guint8 * code.1184;
  unsigned int D.25679;
  unsigned int D.25680;
  unsigned int regs_offset.1185;
  unsigned int D.25682;
  int D.25683;
  guint8 * code.1186;
  guint8 * code.1187;
  signed char D.25688;
  unsigned char D.25689;
  guint8 * code.1188;
  guint8 * code.1189;
  unsigned char D.25692;
  unsigned char D.25693;
  unsigned char D.25694;
  unsigned char D.25695;
  guint8 * code.1190;
  guint8 * code.1191;
  signed char D.25698;
  unsigned char D.25699;
  guint8 * code.1192;
  guint8 * code.1193;
  guint8 * code.1194;
  guint8 * code.1195;
  unsigned char D.25704;
  guint8 * code.1196;
  guint8 * code.1197;
  unsigned char D.25707;
  guint8 * code.1198;
  guint8 * code.1199;
  unsigned char D.25710;
  guint8 * code.1200;
  guint8 * code.1201;
  unsigned char D.25713;
  guint8 * code.1202;
  guint8 * code.1203;
  guint8 * code.1204;
  guint8 * code.1205;
  guint8 * code.1206;
  guint8 * code.1207;
  guint8 * code.1208;
  guint8 * code.1209;
  unsigned char D.25728;
  guint8 * code.1210;
  guint8 * code.1211;
  unsigned char D.25731;
  guint8 * code.1212;
  guint8 * code.1213;
  unsigned char D.25734;
  guint8 * code.1214;
  guint8 * code.1215;
  unsigned char D.25737;
  guint8 * code.1216;
  guint8 * code.1217;
  unsigned char D.25742;
  guint8 * code.1218;
  guint8 * code.1219;
  guint8 * code.1220;
  guint8 * code.1221;
  unsigned int D.25749;
  int D.25750;
  guint8 * code.1222;
  guint8 * code.1223;
  unsigned char D.25753;
  guint8 * code.1224;
  guint8 * code.1225;
  unsigned char D.25756;
  guint8 * code.1226;
  guint8 * code.1227;
  unsigned char D.25759;
  guint8 * code.1228;
  guint8 * code.1229;
  unsigned char D.25762;
  long unsigned int D.25766;
  guint8 * code.1230;
  guint8 * code.1231;
  guint8 * code.1232;
  guint8 * code.1233;
  guint8 * code.1234;
  guint8 * code.1235;
  guint8 * code.1236;
  guint8 * code.1237;
  unsigned char D.25782;
  unsigned char D.25783;
  guint8 * code.1238;
  guint8 * code.1239;
  guint8 * code.1240;
  guint8 * code.1241;
  guint8 * code.1242;
  guint8 * code.1243;
  unsigned char D.25790;
  guint8 * code.1244;
  guint8 * code.1245;
  unsigned char D.25793;
  guint8 * code.1246;
  guint8 * code.1247;
  unsigned char D.25796;
  guint8 * code.1248;
  guint8 * code.1249;
  unsigned char D.25799;
  guint8 * code.1250;
  guint8 * code.1251;
  guint8 * code.1252;
  guint8 * code.1253;
  guint8 * code.1254;
  guint8 * code.1255;
  guint8 * code.1256;
  guint8 * code.1257;
  unsigned char D.25814;
  guint8 * code.1258;
  guint8 * code.1259;
  unsigned char D.25817;
  guint8 * code.1260;
  guint8 * code.1261;
  unsigned char D.25820;
  guint8 * code.1262;
  guint8 * code.1263;
  unsigned char D.25823;
  guint8 * code.1264;
  guint8 * code.1265;
  guint8 * code.1266;
  guint8 * code.1267;
  unsigned char D.25832;
  guint8 * code.1268;
  guint8 * code.1269;
  guint8 * code.1270;
  guint8 * code.1271;
  guint8 * code.1272;
  guint8 * code.1273;
  guint8 * code.1274;
  guint8 * code.1275;
  unsigned int D.25848;
  int D.25849;
  guint8 * code.1276;
  guint8 * code.1277;
  guint8 * code.1278;
  guint8 * code.1279;
  unsigned char D.25856;
  guint8 * code.1280;
  guint8 * code.1281;
  guint8 * code.1282;
  guint8 * code.1283;
  guint8 * code.1284;
  guint8 * code.1285;
  unsigned char D.25863;
  guint8 * code.1286;
  guint8 * code.1287;
  unsigned char D.25866;
  guint8 * code.1288;
  guint8 * code.1289;
  unsigned char D.25869;
  guint8 * code.1290;
  guint8 * code.1291;
  unsigned char D.25872;
  guint8 * code.1292;
  guint8 * code.1293;
  guint8 * code.1294;
  guint8 * code.1295;
  guint8 * code.1296;
  guint8 * code.1297;
  guint8 * code.1298;
  guint8 * code.1299;
  unsigned char D.25887;
  guint8 * code.1300;
  guint8 * code.1301;
  unsigned char D.25890;
  guint8 * code.1302;
  guint8 * code.1303;
  unsigned char D.25893;
  guint8 * code.1304;
  guint8 * code.1305;
  unsigned char D.25896;
  guint8 * code.1306;
  guint8 * code.1307;
  unsigned char D.25901;
  guint8 * code.1308;
  guint8 * code.1309;
  guint8 * code.1310;
  guint8 * code.1311;
  guint8 * code.1312;
  guint8 * code.1313;
  unsigned char D.25910;
  guint8 * code.1314;
  guint8 * code.1315;
  unsigned char D.25913;
  guint8 * code.1316;
  guint8 * code.1317;
  unsigned char D.25916;
  guint8 * code.1318;
  guint8 * code.1319;
  unsigned char D.25919;
  guint8 * code.1320;
  guint8 * code.1321;
  guint8 * code.1322;
  guint8 * code.1323;
  unsigned int D.25930;
  guint8 * code.1324;
  guint8 * code.1325;
  guint8 * code.1326;
  guint8 * code.1327;
  unsigned char D.25937;
  guint8 * code.1328;
  guint8 * code.1329;
  guint8 * code.1330;
  guint8 * code.1331;
  guint8 * code.1332;
  guint8 * code.1333;
  unsigned char D.25945;
  guint8 * code.1334;
  guint8 * code.1335;
  unsigned char D.25948;
  guint8 * code.1336;
  guint8 * code.1337;
  unsigned char D.25951;
  guint8 * code.1338;
  guint8 * code.1339;
  unsigned char D.25954;
  guint8 * code.1340;
  guint8 * code.1341;
  guint8 * code.1342;
  guint8 * code.1343;
  guint8 * code.1344;
  guint8 * code.1345;
  guint8 * code.1346;
  guint8 * code.1347;
  unsigned char D.25968;
  guint8 * code.1348;
  guint8 * code.1349;
  unsigned char D.25971;
  guint8 * code.1350;
  guint8 * code.1351;
  unsigned char D.25974;
  guint8 * code.1352;
  guint8 * code.1353;
  unsigned char D.25977;
  guint8 * code.1354;
  guint8 * code.1355;
  guint8 * code.1356;
  guint8 * code.1357;
  unsigned char D.25986;
  guint8 * code.1358;
  guint8 * code.1359;
  guint8 * code.1360;
  guint8 * code.1361;
  int D.25993;
  guint8 * code.1362;
  guint8 * code.1363;
  guint8 * code.1364;
  guint8 * code.1365;
  unsigned int D.26001;
  unsigned int D.26002;
  guint8 * code.1366;
  guint8 * code.1367;
  guint8 * code.1368;
  guint8 * code.1369;
  unsigned char D.26009;
  guint8 * code.1370;
  guint8 * code.1371;
  guint8 * code.1372;
  guint8 * code.1373;
  guint8 * code.1374;
  guint8 * code.1375;
  unsigned char D.26017;
  guint8 * code.1376;
  guint8 * code.1377;
  unsigned char D.26020;
  guint8 * code.1378;
  guint8 * code.1379;
  unsigned char D.26023;
  guint8 * code.1380;
  guint8 * code.1381;
  unsigned char D.26026;
  guint8 * code.1382;
  guint8 * code.1383;
  guint8 * code.1384;
  guint8 * code.1385;
  guint8 * code.1386;
  guint8 * code.1387;
  guint8 * code.1388;
  guint8 * code.1389;
  unsigned char D.26040;
  guint8 * code.1390;
  guint8 * code.1391;
  unsigned char D.26043;
  guint8 * code.1392;
  guint8 * code.1393;
  unsigned char D.26046;
  guint8 * code.1394;
  guint8 * code.1395;
  unsigned char D.26049;
  guint8 * code.1396;
  guint8 * code.1397;
  unsigned char D.26056;
  guint8 * code.1398;
  guint8 * code.1399;
  guint8 * code.1400;
  guint8 * code.1401;
  guint8 * code.1402;
  guint8 * code.1403;
  guint8 * code.1404;
  guint8 * code.1405;
  unsigned char D.26070;
  guint8 * code.1406;
  guint8 * code.1407;
  guint8 * code.1408;
  guint8 * code.1409;
  guint8 * code.1410;
  guint8 * code.1411;
  guint8 * code.1412;
  guint8 * code.1413;
  unsigned char D.26081;
  guint8 * code.1414;
  guint8 * code.1415;
  unsigned char D.26084;
  guint8 * code.1416;
  guint8 * code.1417;
  unsigned char D.26087;
  guint8 * code.1418;
  guint8 * code.1419;
  unsigned char D.26090;
  guint8 * code.1420;
  guint8 * code.1421;
  guint8 * code.1422;
  guint8 * code.1423;
  guint8 * code.1424;
  guint8 * code.1425;
  guint8 * code.1426;
  guint8 * code.1427;
  guint8 * code.1428;
  guint8 * code.1429;
  guint8 * code.1430;
  guint8 * code.1431;
  guint8 * code.1432;
  guint8 * code.1433;
  unsigned char D.26114;
  guint8 * code.1434;
  guint8 * code.1435;
  unsigned char D.26117;
  guint8 * code.1436;
  guint8 * code.1437;
  unsigned char D.26120;
  guint8 * code.1438;
  guint8 * code.1439;
  unsigned char D.26123;
  guint8 * code.1440;
  guint8 * code.1441;
  guint8 * code.1442;
  guint8 * code.1443;
  guint8 * code.1444;
  guint8 * code.1445;
  guint8 * code.1446;
  guint8 * code.1447;
  unsigned char D.26137;
  guint8 * code.1448;
  guint8 * code.1449;
  unsigned char D.26140;
  guint8 * code.1450;
  guint8 * code.1451;
  unsigned char D.26143;
  guint8 * code.1452;
  guint8 * code.1453;
  unsigned char D.26146;
  guint8 * code.1454;
  guint8 * code.1455;
  guint8 * code.1456;
  guint8 * code.1457;
  unsigned char D.26155;
  guint8 * code.1458;
  guint8 * code.1459;
  guint8 * code.1460;
  guint8 * code.1461;
  int D.26162;
  guint8 * code.1462;
  guint8 * code.1463;
  guint8 * code.1464;
  guint8 * code.1465;
  unsigned int D.26170;
  unsigned int D.26171;
  guint8 * code.1466;
  guint8 * code.1467;
  guint8 * code.1468;
  guint8 * code.1469;
  unsigned char D.26178;
  guint8 * code.1470;
  guint8 * code.1471;
  guint8 * code.1472;
  guint8 * code.1473;
  guint8 * code.1474;
  guint8 * code.1475;
  unsigned char D.26186;
  guint8 * code.1476;
  guint8 * code.1477;
  unsigned char D.26189;
  guint8 * code.1478;
  guint8 * code.1479;
  unsigned char D.26192;
  guint8 * code.1480;
  guint8 * code.1481;
  unsigned char D.26195;
  guint8 * code.1482;
  guint8 * code.1483;
  guint8 * code.1484;
  guint8 * code.1485;
  guint8 * code.1486;
  guint8 * code.1487;
  guint8 * code.1488;
  guint8 * code.1489;
  unsigned char D.26209;
  guint8 * code.1490;
  guint8 * code.1491;
  unsigned char D.26212;
  guint8 * code.1492;
  guint8 * code.1493;
  unsigned char D.26215;
  guint8 * code.1494;
  guint8 * code.1495;
  unsigned char D.26218;
  guint8 * code.1496;
  guint8 * code.1497;
  guint8 * code.1498;
  guint8 * code.1499;
  unsigned char D.26229;
  guint8 * code.1500;
  guint8 * code.1501;
  int D.26236;
  guint8 * code.1502;
  guint8 * code.1503;
  guint8 * code.1504;
  guint8 * code.1505;
  unsigned int D.26244;
  unsigned int D.26245;
  guint8 * code.1506;
  guint8 * code.1507;
  guint8 * code.1508;
  guint8 * code.1509;
  unsigned char D.26252;
  guint8 * code.1510;
  guint8 * code.1511;
  guint8 * code.1512;
  guint8 * code.1513;
  guint8 * code.1514;
  guint8 * code.1515;
  unsigned char D.26260;
  guint8 * code.1516;
  guint8 * code.1517;
  unsigned char D.26263;
  guint8 * code.1518;
  guint8 * code.1519;
  unsigned char D.26266;
  guint8 * code.1520;
  guint8 * code.1521;
  unsigned char D.26269;
  guint8 * code.1522;
  guint8 * code.1523;
  guint8 * code.1524;
  guint8 * code.1525;
  guint8 * code.1526;
  guint8 * code.1527;
  guint8 * code.1528;
  guint8 * code.1529;
  unsigned char D.26283;
  guint8 * code.1530;
  guint8 * code.1531;
  unsigned char D.26286;
  guint8 * code.1532;
  guint8 * code.1533;
  unsigned char D.26289;
  guint8 * code.1534;
  guint8 * code.1535;
  unsigned char D.26292;
  guint8 * code.1536;
  guint8 * code.1537;
  guint8 * code.1538;
  guint8 * code.1539;
  guint8 * code.1540;
  guint8 * code.1541;
  guint8 * code.1542;
  guint8 * code.1543;
  guint8 * code.1544;
  guint8 * code.1545;
  guint8 * code.1546;
  guint8 * code.1547;
  guint8 * code.1548;
  guint8 * code.1549;
  guint8 * code.1550;
  guint8 * code.1551;
  unsigned char D.26320;
  guint8 * code.1552;
  guint8 * code.1553;
  unsigned char D.26323;
  guint8 * code.1554;
  guint8 * code.1555;
  unsigned char D.26326;
  guint8 * code.1556;
  guint8 * code.1557;
  unsigned char D.26329;
  guint8 * code.1558;
  guint8 * code.1559;
  guint8 * code.1560;
  guint8 * code.1561;
  guint8 * code.1562;
  guint8 * code.1563;
  guint8 * code.1564;
  guint8 * code.1565;
  unsigned char D.26343;
  guint8 * code.1566;
  guint8 * code.1567;
  unsigned char D.26346;
  guint8 * code.1568;
  guint8 * code.1569;
  unsigned char D.26349;
  guint8 * code.1570;
  guint8 * code.1571;
  unsigned char D.26352;
  guint8 * code.1572;
  guint8 * code.1573;
  guint8 * code.1574;
  guint8 * code.1575;
  guint8 * code.1576;
  guint8 * code.1577;
  guint8 * code.1578;
  guint8 * code.1579;
  guint8 * code.1580;
  guint8 * code.1581;
  guint8 * code.1582;
  guint8 * code.1583;
  guint8 * code.1584;
  guint8 * code.1585;
  guint8 * code.1586;
  guint8 * code.1587;
  guint8 * code.1588;
  unsigned char D.26379;
  guint8 * code.1589;
  guint8 * code.1590;
  unsigned char D.26382;
  guint8 * code.1591;
  guint8 * code.1592;
  unsigned char D.26385;
  guint8 * code.1593;
  guint8 * code.1594;
  unsigned char D.26388;
  guint8 * code.1595;
  guint8 * code.1596;
  guint8 * code.1597;
  guint8 * code.1598;
  guint8 * code.1599;
  guint8 * code.1600;
  guint8 * code.1601;
  guint8 * code.1602;
  unsigned char D.26402;
  guint8 * code.1603;
  guint8 * code.1604;
  unsigned char D.26405;
  guint8 * code.1605;
  guint8 * code.1606;
  unsigned char D.26408;
  guint8 * code.1607;
  guint8 * code.1608;
  unsigned char D.26411;
  guint8 * code.1609;
  guint8 * code.1610;
  unsigned char D.26414;
  guint8 * code.1611;
  guint8 * code.1612;
  unsigned char D.26417;
  guint8 * code.1613;
  guint8 * code.1614;
  unsigned char D.26420;
  guint8 * code.1615;
  guint8 * code.1616;
  unsigned char D.26423;
  guint8 * code.1617;
  guint8 * code.1618;
  guint8 * code.1619;
  guint8 * code.1620;
  unsigned char D.26433;
  guint8 * code.1621;
  guint8 * code.1622;
  guint8 * code.1623;
  guint8 * code.1624;
  guint8 * code.1625;
  guint8 * code.1626;
  guint8 * code.1627;
  guint8 * code.1628;
  guint8 * code.1629;
  guint8 * code.1630;
  guint8 * code.1631;
  guint8 * code.1632;
  guint8 * code.1633;
  guint8 * code.1634;
  guint8 * code.1635;
  guint8 * code.1636;
  guint8 * code.1637;
  guint8 * code.1638;
  unsigned char D.26460;
  guint8 * code.1639;
  guint8 * code.1640;
  unsigned char D.26463;
  guint8 * code.1641;
  guint8 * code.1642;
  unsigned char D.26466;
  guint8 * code.1643;
  guint8 * code.1644;
  unsigned char D.26469;
  guint8 * code.1645;
  guint8 * code.1646;
  guint8 * code.1647;
  guint8 * code.1648;
  guint8 * code.1649;
  guint8 * code.1650;
  guint8 * code.1651;
  guint8 * code.1652;
  unsigned char D.26483;
  guint8 * code.1653;
  guint8 * code.1654;
  unsigned char D.26486;
  guint8 * code.1655;
  guint8 * code.1656;
  unsigned char D.26489;
  guint8 * code.1657;
  guint8 * code.1658;
  unsigned char D.26492;
  guint8 * code.1659;
  guint8 * code.1660;
  guint8 * code.1661;
  guint8 * code.1662;
  unsigned char D.26503;
  guint8 * code.1663;
  guint8 * code.1664;
  int D.26510;
  guint8 * code.1665;
  guint8 * code.1666;
  guint8 * code.1667;
  guint8 * code.1668;
  unsigned int D.26518;
  unsigned int D.26519;
  guint8 * code.1669;
  guint8 * code.1670;
  guint8 * code.1671;
  guint8 * code.1672;
  unsigned char D.26526;
  guint8 * code.1673;
  guint8 * code.1674;
  guint8 * code.1675;
  guint8 * code.1676;
  guint8 * code.1677;
  guint8 * code.1678;
  unsigned char D.26534;
  guint8 * code.1679;
  guint8 * code.1680;
  unsigned char D.26537;
  guint8 * code.1681;
  guint8 * code.1682;
  unsigned char D.26540;
  guint8 * code.1683;
  guint8 * code.1684;
  unsigned char D.26543;
  guint8 * code.1685;
  guint8 * code.1686;
  guint8 * code.1687;
  guint8 * code.1688;
  guint8 * code.1689;
  guint8 * code.1690;
  guint8 * code.1691;
  guint8 * code.1692;
  unsigned char D.26557;
  guint8 * code.1693;
  guint8 * code.1694;
  unsigned char D.26560;
  guint8 * code.1695;
  guint8 * code.1696;
  unsigned char D.26563;
  guint8 * code.1697;
  guint8 * code.1698;
  unsigned char D.26566;
  guint8 * code.1699;
  guint8 * code.1700;
  guint8 * code.1701;
  guint8 * code.1702;
  guint8 * code.1703;
  guint8 * code.1704;
  guint8 * code.1705;
  guint8 * code.1706;
  guint8 * code.1707;
  guint8 * code.1708;
  guint8 * code.1709;
  guint8 * code.1710;
  guint8 * code.1711;
  guint8 * code.1712;
  guint8 * code.1713;
  guint8 * code.1714;
  unsigned char D.26594;
  guint8 * code.1715;
  guint8 * code.1716;
  unsigned char D.26597;
  guint8 * code.1717;
  guint8 * code.1718;
  unsigned char D.26600;
  guint8 * code.1719;
  guint8 * code.1720;
  unsigned char D.26603;
  guint8 * code.1721;
  guint8 * code.1722;
  guint8 * code.1723;
  guint8 * code.1724;
  guint8 * code.1725;
  guint8 * code.1726;
  guint8 * code.1727;
  guint8 * code.1728;
  unsigned char D.26617;
  guint8 * code.1729;
  guint8 * code.1730;
  unsigned char D.26620;
  guint8 * code.1731;
  guint8 * code.1732;
  unsigned char D.26623;
  guint8 * code.1733;
  guint8 * code.1734;
  unsigned char D.26626;
  guint8 * code.1735;
  guint8 * code.1736;
  guint8 * code.1737;
  guint8 * code.1738;
  guint8 * code.1739;
  guint8 * code.1740;
  guint8 * code.1741;
  guint8 * code.1742;
  guint8 * code.1743;
  guint8 * code.1744;
  guint8 * code.1745;
  guint8 * code.1746;
  guint8 * code.1747;
  guint8 * code.1748;
  guint8 * code.1749;
  guint8 * code.1750;
  unsigned char D.26652;
  guint8 * code.1751;
  guint8 * code.1752;
  unsigned char D.26655;
  guint8 * code.1753;
  guint8 * code.1754;
  unsigned char D.26658;
  guint8 * code.1755;
  guint8 * code.1756;
  unsigned char D.26661;
  guint8 * code.1757;
  guint8 * code.1758;
  guint8 * code.1759;
  guint8 * code.1760;
  guint8 * code.1761;
  guint8 * code.1762;
  guint8 * code.1763;
  guint8 * code.1764;
  unsigned char D.26675;
  guint8 * code.1765;
  guint8 * code.1766;
  unsigned char D.26678;
  guint8 * code.1767;
  guint8 * code.1768;
  unsigned char D.26681;
  guint8 * code.1769;
  guint8 * code.1770;
  unsigned char D.26684;
  guint8 * code.1771;
  guint8 * code.1772;
  unsigned char D.26687;
  guint8 * code.1773;
  guint8 * code.1774;
  unsigned char D.26690;
  guint8 * code.1775;
  guint8 * code.1776;
  unsigned char D.26693;
  guint8 * code.1777;
  guint8 * code.1778;
  unsigned char D.26696;
  guint8 * code.1779;
  guint8 * code.1780;
  guint8 * code.1781;
  guint8 * code.1782;
  unsigned char D.26708;
  guint8 * code.1783;
  guint8 * code.1784;
  guint8 * code.1785;
  guint8 * code.1786;
  guint8 * code.1787;
  guint8 * code.1788;
  guint8 * code.1789;
  guint8 * code.1790;
  guint8 * code.1791;
  guint8 * code.1792;
  guint8 * code.1793;
  guint8 * code.1794;
  guint8 * code.1795;
  guint8 * code.1796;
  guint8 * code.1797;
  guint8 * code.1798;
  guint8 * code.1799;
  guint8 * code.1800;
  unsigned char D.26735;
  guint8 * code.1801;
  guint8 * code.1802;
  unsigned char D.26738;
  guint8 * code.1803;
  guint8 * code.1804;
  unsigned char D.26741;
  guint8 * code.1805;
  guint8 * code.1806;
  unsigned char D.26744;
  guint8 * code.1807;
  guint8 * code.1808;
  guint8 * code.1809;
  guint8 * code.1810;
  guint8 * code.1811;
  guint8 * code.1812;
  guint8 * code.1813;
  guint8 * code.1814;
  unsigned char D.26758;
  guint8 * code.1815;
  guint8 * code.1816;
  unsigned char D.26761;
  guint8 * code.1817;
  guint8 * code.1818;
  unsigned char D.26764;
  guint8 * code.1819;
  guint8 * code.1820;
  unsigned char D.26767;
  guint8 * code.1821;
  guint8 * code.1822;
  unsigned char D.26774;
  guint8 * code.1823;
  guint8 * code.1824;
  guint8 * code.1825;
  guint8 * code.1826;
  guint8 * code.1827;
  guint8 * code.1828;
  guint8 * code.1829;
  guint8 * code.1830;
  guint8 * code.1831;
  guint8 * code.1832;
  guint8 * code.1833;
  guint8 * code.1834;
  guint8 * code.1835;
  guint8 * code.1836;
  guint8 * code.1837;
  guint8 * code.1838;
  unsigned char D.26799;
  guint8 * code.1839;
  guint8 * code.1840;
  unsigned char D.26802;
  guint8 * code.1841;
  guint8 * code.1842;
  unsigned char D.26805;
  guint8 * code.1843;
  guint8 * code.1844;
  unsigned char D.26808;
  guint8 * code.1845;
  guint8 * code.1846;
  guint8 * code.1847;
  guint8 * code.1848;
  guint8 * code.1849;
  guint8 * code.1850;
  guint8 * code.1851;
  guint8 * code.1852;
  unsigned char D.26822;
  guint8 * code.1853;
  guint8 * code.1854;
  unsigned char D.26825;
  guint8 * code.1855;
  guint8 * code.1856;
  unsigned char D.26828;
  guint8 * code.1857;
  guint8 * code.1858;
  unsigned char D.26831;
  guint8 * code.1859;
  guint8 * code.1860;
  guint8 * code.1861;
  guint8 * code.1862;
  unsigned char D.26841;
  guint8 * code.1863;
  guint8 * code.1864;
  guint8 * code.1865;
  guint8 * code.1866;
  guint8 * code.1867;
  guint8 * code.1868;
  guint8 * code.1869;
  guint8 * code.1870;
  guint8 * code.1871;
  guint8 * code.1872;
  guint8 * code.1873;
  guint8 * code.1874;
  guint8 * code.1875;
  guint8 * code.1876;
  guint8 * code.1877;
  guint8 * code.1878;
  unsigned char D.26868;
  guint8 * code.1879;
  guint8 * code.1880;
  unsigned char D.26871;
  guint8 * code.1881;
  guint8 * code.1882;
  unsigned char D.26874;
  guint8 * code.1883;
  guint8 * code.1884;
  unsigned char D.26877;
  guint8 * code.1885;
  guint8 * code.1886;
  guint8 * code.1887;
  guint8 * code.1888;
  guint8 * code.1889;
  guint8 * code.1890;
  guint8 * code.1891;
  guint8 * code.1892;
  unsigned char D.26891;
  guint8 * code.1893;
  guint8 * code.1894;
  unsigned char D.26894;
  guint8 * code.1895;
  guint8 * code.1896;
  unsigned char D.26897;
  guint8 * code.1897;
  guint8 * code.1898;
  unsigned char D.26900;
  unsigned char D.26901;
  guint8 * code.1899;
  guint8 * code.1900;
  guint8 * code.1901;
  guint8 * code.1902;
  guint8 * code.1903;
  guint8 * code.1904;
  guint8 * code.1905;
  guint8 * code.1906;
  guint8 * code.1907;
  guint8 * code.1908;
  guint8 * code.1909;
  guint8 * code.1910;
  guint8 * code.1911;
  guint8 * code.1912;
  guint8 * code.1913;
  guint8 * code.1914;
  unsigned char D.26929;
  guint8 * code.1915;
  guint8 * code.1916;
  unsigned char D.26932;
  guint8 * code.1917;
  guint8 * code.1918;
  unsigned char D.26935;
  guint8 * code.1919;
  guint8 * code.1920;
  unsigned char D.26938;
  guint8 * code.1921;
  guint8 * code.1922;
  guint8 * code.1923;
  guint8 * code.1924;
  guint8 * code.1925;
  guint8 * code.1926;
  guint8 * code.1927;
  guint8 * code.1928;
  unsigned char D.26952;
  guint8 * code.1929;
  guint8 * code.1930;
  unsigned char D.26955;
  guint8 * code.1931;
  guint8 * code.1932;
  unsigned char D.26958;
  guint8 * code.1933;
  guint8 * code.1934;
  unsigned char D.26961;
  short int D.26962;
  guint8 * code.1935;
  guint8 * code.1936;
  guint8 * code.1937;
  guint8 * code.1938;
  guint8 * code.1939;
  guint8 * code.1940;
  guint8 * code.1941;
  guint8 * code.1942;
  guint8 * code.1943;
  guint8 * code.1944;
  guint8 * code.1945;
  guint8 * code.1946;
  guint8 * code.1947;
  guint8 * code.1948;
  guint8 * code.1949;
  guint8 * code.1950;
  unsigned char D.26988;
  guint8 * code.1951;
  guint8 * code.1952;
  unsigned char D.26991;
  guint8 * code.1953;
  guint8 * code.1954;
  unsigned char D.26994;
  guint8 * code.1955;
  guint8 * code.1956;
  unsigned char D.26997;
  guint8 * code.1957;
  guint8 * code.1958;
  guint8 * code.1959;
  guint8 * code.1960;
  guint8 * code.1961;
  guint8 * code.1962;
  guint8 * code.1963;
  guint8 * code.1964;
  unsigned char D.27011;
  guint8 * code.1965;
  guint8 * code.1966;
  unsigned char D.27014;
  guint8 * code.1967;
  guint8 * code.1968;
  unsigned char D.27017;
  guint8 * code.1969;
  guint8 * code.1970;
  unsigned char D.27020;
  guint8 * code.1971;
  guint8 * code.1972;
  unsigned char D.27023;
  guint8 * code.1973;
  guint8 * code.1974;
  unsigned char D.27026;
  guint8 * code.1975;
  guint8 * code.1976;
  unsigned char D.27029;
  guint8 * code.1977;
  guint8 * code.1978;
  unsigned char D.27032;
  const void * iftmp.1979;
  guint8 * code.1980;
  guint8 * code.1981;
  guint8 * code.1982;
  guint8 * code.1983;
  unsigned char D.27047;
  guint8 * code.1984;
  guint8 * code.1985;
  guint8 * code.1986;
  guint8 * code.1987;
  guint8 * code.1988;
  guint8 * code.1989;
  guint8 * code.1990;
  guint8 * code.1991;
  unsigned char D.27058;
  guint8 * code.1992;
  guint8 * code.1993;
  unsigned char D.27061;
  guint8 * code.1994;
  guint8 * code.1995;
  unsigned char D.27064;
  guint8 * code.1996;
  guint8 * code.1997;
  unsigned char D.27067;
  guint8 * code.1998;
  guint8 * code.1999;
  guint8 * code.2000;
  guint8 * code.2001;
  guint8 * code.2002;
  guint8 * code.2003;
  guint8 * code.2004;
  guint8 * code.2005;
  guint8 * code.2006;
  guint8 * code.2007;
  guint8 * code.2008;
  guint8 * code.2009;
  guint8 * code.2010;
  guint8 * code.2011;
  unsigned char D.27091;
  guint8 * code.2012;
  guint8 * code.2013;
  unsigned char D.27094;
  guint8 * code.2014;
  guint8 * code.2015;
  unsigned char D.27097;
  guint8 * code.2016;
  guint8 * code.2017;
  unsigned char D.27100;
  guint8 * code.2018;
  guint8 * code.2019;
  guint8 * code.2020;
  guint8 * code.2021;
  guint8 * code.2022;
  guint8 * code.2023;
  guint8 * code.2024;
  guint8 * code.2025;
  unsigned char D.27114;
  guint8 * code.2026;
  guint8 * code.2027;
  unsigned char D.27117;
  guint8 * code.2028;
  guint8 * code.2029;
  unsigned char D.27120;
  guint8 * code.2030;
  guint8 * code.2031;
  unsigned char D.27123;
  long unsigned int iftmp.2032;
  long unsigned int iftmp.2033;
  long unsigned int iftmp.2034;
  long unsigned int iftmp.2035;
  long int mono_amd64_throw_corlib_exception.2036;
  int D.27140;
  long int mono_amd64_throw_exception.2037;
  int D.27143;
  long int mono_amd64_resume_unwind.2038;
  int D.27146;
  _Bool D.27147;
  unsigned char iftmp.2039;
  guint8 * code.2040;
  guint8 * code.2041;
  unsigned char D.27156;
  guint8 * code.2042;
  guint8 * code.2043;
  long unsigned int iftmp.2044;
  long unsigned int iftmp.2045;
  guint8 * code.2046;
  guint8 * code.2047;
  unsigned char D.27171;
  guint8 * code.2048;
  guint8 * code.2049;
  unsigned char D.27174;
  guint8 * code.2050;
  guint8 * code.2051;
  unsigned char D.27177;
  guint8 * code.2052;
  guint8 * code.2053;
  unsigned char D.27180;
  guint8 * code.2054;
  guint8 * code.2055;
  unsigned char D.27183;
  guint8 * code.2056;
  guint8 * code.2057;
  unsigned char D.27186;
  guint8 * code.2058;
  guint8 * code.2059;
  unsigned char D.27189;
  guint8 * code.2060;
  guint8 * code.2061;
  unsigned char D.27192;
  int iftmp.2062;
  int iftmp.2063;
  guint8 * code.2064;
  guint8 * code.2065;
  unsigned char D.27204;
  guint8 * code.2066;
  guint8 * code.2067;
  unsigned char D.27207;
  guint8 * code.2068;
  guint8 * code.2069;
  unsigned char D.27210;
  guint8 * code.2070;
  guint8 * code.2071;
  unsigned char D.27213;
  guint8 * code.2072;
  guint8 * code.2073;
  unsigned char D.27218;
  guint8 * code.2074;
  guint8 * code.2075;
  guint8 * code.2076;
  guint8 * code.2077;
  guint8 * code.2078;
  guint8 * code.2079;
  int D.27225;
  _Bool D.27226;
  long int D.27227;
  long int D.27228;
  unsigned int D.27233;
  struct MonoTrampInfo * D.27234;
  void * D.27235;
  guint8 * start;
  guint8 * code;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  int i;
  int stack_size;
  int arg_offsets[16];
  int regs_offset;
  int dummy_stack_space;
  const guint kMaxCodeSize;
  static const char __PRETTY_FUNCTION__[21] = "get_throw_trampoline";

  try
    {
      ji = 0B;
      unwind_ops = 0B;
      kMaxCodeSize = 256;
      dummy_stack_space = 0;
      kMaxCodeSize.1131 = (int) kMaxCodeSize;
      code.1132 = mono_global_codeman_reserve (kMaxCodeSize.1131);
      code = code.1132;
      code.1133 = code;
      start = code.1133;
      stack_size = dummy_stack_space + 200;
      start.1134 = start;
      code = start.1134;
      if (info != 0B) goto <D.25563>; else goto <D.25564>;
      <D.25563>:
      unwind_ops = mono_arch_get_cie_program ();
      <D.25564>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25566 = stack_size.1135 + 128;
      if (D.25566 <= 255) goto <D.25567>; else goto <D.25568>;
      <D.25567>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25569>; else goto <D.25570>;
        <D.25569>:
        code.1133 = code;
        code.1136 = code.1133;
        code.1137 = code.1136 + 1;
        code = code.1137;
        D.25573 = _amd64_rex_bits | 64;
        *code.1136 = D.25573;
        <D.25570>:
      }
      code.1133 = code;
      code.1138 = code.1133;
      code.1139 = code.1138 + 1;
      code = code.1139;
      *code.1138 = 131;
      code.1133 = code;
      code.1140 = code.1133;
      code.1141 = code.1140 + 1;
      code = code.1141;
      *code.1140 = 236;
      code.1133 = code;
      D.25578 = (unsigned char) stack_size;
      *code.1133 = D.25578;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25580>;
      <D.25568>:
      if (0 != 0) goto <D.25581>; else goto <D.25582>;
      <D.25581>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25583>; else goto <D.25584>;
        <D.25583>:
        code.1133 = code;
        code.1143 = code.1133;
        code.1144 = code.1143 + 1;
        code = code.1144;
        D.25587 = _amd64_rex_bits | 64;
        *code.1143 = D.25587;
        <D.25584>:
      }
      code.1133 = code;
      code.1145 = code.1133;
      code.1146 = code.1145 + 1;
      code = code.1146;
      *code.1145 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = stack_size;
            code.1133 = code;
            code.1147 = code.1133;
            code.1148 = code.1147 + 1;
            code = code.1148;
            D.25592 = imb.b[0];
            *code.1147 = D.25592;
            code.1133 = code;
            code.1149 = code.1133;
            code.1150 = code.1149 + 1;
            code = code.1150;
            D.25595 = imb.b[1];
            *code.1149 = D.25595;
            code.1133 = code;
            code.1151 = code.1133;
            code.1152 = code.1151 + 1;
            code = code.1152;
            D.25598 = imb.b[2];
            *code.1151 = D.25598;
            code.1133 = code;
            code.1153 = code.1133;
            code.1154 = code.1153 + 1;
            code = code.1154;
            D.25601 = imb.b[3];
            *code.1153 = D.25601;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25602>;
      <D.25582>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25603>; else goto <D.25604>;
        <D.25603>:
        code.1133 = code;
        code.1155 = code.1133;
        code.1156 = code.1155 + 1;
        code = code.1156;
        D.25607 = _amd64_rex_bits | 64;
        *code.1155 = D.25607;
        <D.25604>:
      }
      code.1133 = code;
      code.1157 = code.1133;
      code.1158 = code.1157 + 1;
      code = code.1158;
      *code.1157 = 129;
      code.1133 = code;
      code.1159 = code.1133;
      code.1160 = code.1159 + 1;
      code = code.1160;
      *code.1159 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = stack_size;
            code.1133 = code;
            code.1161 = code.1133;
            code.1162 = code.1161 + 1;
            code = code.1162;
            D.25614 = imb.b[0];
            *code.1161 = D.25614;
            code.1133 = code;
            code.1163 = code.1133;
            code.1164 = code.1163 + 1;
            code = code.1164;
            D.25617 = imb.b[1];
            *code.1163 = D.25617;
            code.1133 = code;
            code.1165 = code.1133;
            code.1166 = code.1165 + 1;
            code = code.1166;
            D.25620 = imb.b[2];
            *code.1165 = D.25620;
            code.1133 = code;
            code.1167 = code.1133;
            code.1168 = code.1167 + 1;
            code = code.1168;
            D.25623 = imb.b[3];
            *code.1167 = D.25623;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25602>:
      <D.25580>:
      if (info != 0B) goto <D.25624>; else goto <D.25625>;
      <D.25624>:
      D.25626 = stack_size + 8;
      code.1133 = code;
      code.1169 = (long int) code.1133;
      start.1134 = start;
      start.1170 = (long int) start.1134;
      D.25629 = code.1169 - start.1170;
      D.25630 = (int) D.25629;
      D.25631 = mono_create_unwind_op (D.25630, 14, 0, D.25626);
      unwind_ops = monoeg_g_slist_append (unwind_ops, D.25631);
      <D.25625>:
      arg_offsets[0] = dummy_stack_space;
      dummy_stack_space.1171 = (unsigned int) dummy_stack_space;
      D.25633 = dummy_stack_space.1171 + 8;
      D.25634 = (int) D.25633;
      arg_offsets[1] = D.25634;
      dummy_stack_space.1171 = (unsigned int) dummy_stack_space;
      D.25635 = dummy_stack_space.1171 + 16;
      D.25636 = (int) D.25635;
      arg_offsets[2] = D.25636;
      dummy_stack_space.1171 = (unsigned int) dummy_stack_space;
      D.25637 = dummy_stack_space.1171 + 24;
      D.25638 = (int) D.25637;
      arg_offsets[3] = D.25638;
      dummy_stack_space.1171 = (unsigned int) dummy_stack_space;
      D.25639 = dummy_stack_space.1171 + 32;
      regs_offset = (int) D.25639;
      i = 0;
      goto <D.23113>;
      <D.23112>:
      if (i != 4) goto <D.25640>; else goto <D.25641>;
      <D.25640>:
      if (0 != 0) goto <D.25642>; else goto <D.25643>;
      <D.25642>:
      code.1133 = code;
      code.1172 = code.1133;
      code.1173 = code.1172 + 1;
      code = code.1173;
      *code.1172 = 102;
      <D.25643>:
      {
        unsigned char _amd64_rex_bits;

        if (i > 7) goto <D.25647>; else goto <D.25648>;
        <D.25647>:
        iftmp.1174 = 12;
        goto <D.25649>;
        <D.25648>:
        iftmp.1174 = 8;
        <D.25649>:
        _amd64_rex_bits = iftmp.1174;
        if (_amd64_rex_bits != 0) goto <D.25650>; else goto <D.25651>;
        <D.25650>:
        code.1133 = code;
        code.1175 = code.1133;
        code.1176 = code.1175 + 1;
        code = code.1176;
        D.25654 = _amd64_rex_bits | 64;
        *code.1175 = D.25654;
        <D.25651>:
      }
      switch (8) <default: <D.23107>, case 1: <D.23102>, case 2: <D.23104>, case 4: <D.23105>, case 8: <D.23106>>
      <D.23102>:
      code.1133 = code;
      code.1177 = code.1133;
      code.1178 = code.1177 + 1;
      code = code.1178;
      *code.1177 = 136;
      goto <D.23103>;
      <D.23104>:
      <D.23105>:
      <D.23106>:
      code.1133 = code;
      code.1179 = code.1133;
      code.1180 = code.1179 + 1;
      code = code.1180;
      *code.1179 = 137;
      goto <D.23103>;
      <D.23107>:
      __assert_fail ("0", "exceptions-amd64.c", 475, &__PRETTY_FUNCTION__);
      <D.23103>:
      if (1 != 0) goto <D.25659>; else goto <D.25660>;
      <D.25659>:
      D.25661 = (long unsigned int) regs_offset;
      D.25662 = (long unsigned int) i;
      D.25663 = D.25662 * 8;
      D.25664 = D.25661 + D.25663;
      if (D.25664 == 0) goto <D.25665>; else goto <D.25666>;
      <D.25665>:
      code.1133 = code;
      code.1181 = code.1133;
      code.1182 = code.1181 + 1;
      code = code.1182;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25672 = D.25671 | 4;
      D.25673 = (unsigned char) D.25672;
      *code.1181 = D.25673;
      code.1133 = code;
      code.1183 = code.1133;
      code.1184 = code.1183 + 1;
      code = code.1184;
      *code.1183 = 36;
      goto <D.25676>;
      <D.25666>:
      D.25662 = (long unsigned int) i;
      D.25679 = (unsigned int) D.25662;
      D.25680 = D.25679 * 8;
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25682 = D.25680 + regs_offset.1185;
      D.25683 = (int) D.25682;
      if (D.25683 >= -128) goto <D.25684>; else goto <D.25677>;
      <D.25684>:
      D.25662 = (long unsigned int) i;
      D.25679 = (unsigned int) D.25662;
      D.25680 = D.25679 * 8;
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25682 = D.25680 + regs_offset.1185;
      D.25683 = (int) D.25682;
      if (D.25683 <= 127) goto <D.25685>; else goto <D.25677>;
      <D.25685>:
      code.1133 = code;
      code.1186 = code.1133;
      code.1187 = code.1186 + 1;
      code = code.1187;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25688 = D.25671 | 68;
      D.25689 = (unsigned char) D.25688;
      *code.1186 = D.25689;
      code.1133 = code;
      code.1188 = code.1133;
      code.1189 = code.1188 + 1;
      code = code.1189;
      *code.1188 = 36;
      code.1133 = code;
      D.25692 = (unsigned char) regs_offset;
      D.25662 = (long unsigned int) i;
      D.25693 = (unsigned char) D.25662;
      D.25694 = D.25693 * 8;
      D.25695 = D.25692 + D.25694;
      *code.1133 = D.25695;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25678>;
      <D.25677>:
      code.1133 = code;
      code.1190 = code.1133;
      code.1191 = code.1190 + 1;
      code = code.1191;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25698 = D.25671 | -124;
      D.25699 = (unsigned char) D.25698;
      *code.1190 = D.25699;
      code.1133 = code;
      code.1192 = code.1133;
      code.1193 = code.1192 + 1;
      code = code.1193;
      *code.1192 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.25662 = (long unsigned int) i;
            D.25679 = (unsigned int) D.25662;
            D.25680 = D.25679 * 8;
            regs_offset.1185 = (unsigned int) regs_offset;
            D.25682 = D.25680 + regs_offset.1185;
            D.25683 = (int) D.25682;
            imb.val = D.25683;
            code.1133 = code;
            code.1194 = code.1133;
            code.1195 = code.1194 + 1;
            code = code.1195;
            D.25704 = imb.b[0];
            *code.1194 = D.25704;
            code.1133 = code;
            code.1196 = code.1133;
            code.1197 = code.1196 + 1;
            code = code.1197;
            D.25707 = imb.b[1];
            *code.1196 = D.25707;
            code.1133 = code;
            code.1198 = code.1133;
            code.1199 = code.1198 + 1;
            code = code.1199;
            D.25710 = imb.b[2];
            *code.1198 = D.25710;
            code.1133 = code;
            code.1200 = code.1133;
            code.1201 = code.1200 + 1;
            code = code.1201;
            D.25713 = imb.b[3];
            *code.1200 = D.25713;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25678>:
      <D.25676>:
      goto <D.23110>;
      <D.25660>:
      D.25661 = (long unsigned int) regs_offset;
      D.25662 = (long unsigned int) i;
      D.25663 = D.25662 * 8;
      D.25664 = D.25661 + D.25663;
      if (D.25664 == 0) goto <D.25714>; else goto <D.25715>;
      <D.25714>:
      code.1133 = code;
      code.1202 = code.1133;
      code.1203 = code.1202 + 1;
      code = code.1203;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25672 = D.25671 | 4;
      D.25673 = (unsigned char) D.25672;
      *code.1202 = D.25673;
      goto <D.23110>;
      <D.25715>:
      D.25662 = (long unsigned int) i;
      D.25679 = (unsigned int) D.25662;
      D.25680 = D.25679 * 8;
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25682 = D.25680 + regs_offset.1185;
      D.25683 = (int) D.25682;
      if (D.25683 >= -128) goto <D.25720>; else goto <D.25718>;
      <D.25720>:
      D.25662 = (long unsigned int) i;
      D.25679 = (unsigned int) D.25662;
      D.25680 = D.25679 * 8;
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25682 = D.25680 + regs_offset.1185;
      D.25683 = (int) D.25682;
      if (D.25683 <= 127) goto <D.25721>; else goto <D.25718>;
      <D.25721>:
      code.1133 = code;
      code.1204 = code.1133;
      code.1205 = code.1204 + 1;
      code = code.1205;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25688 = D.25671 | 68;
      D.25689 = (unsigned char) D.25688;
      *code.1204 = D.25689;
      code.1133 = code;
      D.25692 = (unsigned char) regs_offset;
      D.25662 = (long unsigned int) i;
      D.25693 = (unsigned char) D.25662;
      D.25694 = D.25693 * 8;
      D.25695 = D.25692 + D.25694;
      *code.1133 = D.25695;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25719>;
      <D.25718>:
      code.1133 = code;
      code.1206 = code.1133;
      code.1207 = code.1206 + 1;
      code = code.1207;
      D.25669 = i & 7;
      D.25670 = D.25669 << 3;
      D.25671 = (signed char) D.25670;
      D.25698 = D.25671 | -124;
      D.25699 = (unsigned char) D.25698;
      *code.1206 = D.25699;
      {
        union x86_imm_buf imb;

        try
          {
            D.25662 = (long unsigned int) i;
            D.25679 = (unsigned int) D.25662;
            D.25680 = D.25679 * 8;
            regs_offset.1185 = (unsigned int) regs_offset;
            D.25682 = D.25680 + regs_offset.1185;
            D.25683 = (int) D.25682;
            imb.val = D.25683;
            code.1133 = code;
            code.1208 = code.1133;
            code.1209 = code.1208 + 1;
            code = code.1209;
            D.25728 = imb.b[0];
            *code.1208 = D.25728;
            code.1133 = code;
            code.1210 = code.1133;
            code.1211 = code.1210 + 1;
            code = code.1211;
            D.25731 = imb.b[1];
            *code.1210 = D.25731;
            code.1133 = code;
            code.1212 = code.1133;
            code.1213 = code.1212 + 1;
            code = code.1213;
            D.25734 = imb.b[2];
            *code.1212 = D.25734;
            code.1133 = code;
            code.1214 = code.1133;
            code.1215 = code.1214 + 1;
            code = code.1215;
            D.25737 = imb.b[3];
            *code.1214 = D.25737;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25719>:
      <D.23110>:
      <D.25641>:
      i = i + 1;
      <D.23113>:
      if (i <= 16) goto <D.23112>; else goto <D.23114>;
      <D.23114>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25738>; else goto <D.25739>;
        <D.25738>:
        code.1133 = code;
        code.1216 = code.1133;
        code.1217 = code.1216 + 1;
        code = code.1217;
        D.25742 = _amd64_rex_bits | 64;
        *code.1216 = D.25742;
        <D.25739>:
      }
      code.1133 = code;
      code.1218 = code.1133;
      code.1219 = code.1218 + 1;
      code = code.1219;
      *code.1218 = 141;
      if (0 != 0) goto <D.25745>; else goto <D.25746>;
      <D.25745>:
      code.1133 = code;
      code.1220 = code.1133;
      code.1221 = code.1220 + 1;
      code = code.1221;
      *code.1220 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            stack_size.1135 = (unsigned int) stack_size;
            D.25749 = stack_size.1135 + 8;
            D.25750 = (int) D.25749;
            imb.val = D.25750;
            code.1133 = code;
            code.1222 = code.1133;
            code.1223 = code.1222 + 1;
            code = code.1223;
            D.25753 = imb.b[0];
            *code.1222 = D.25753;
            code.1133 = code;
            code.1224 = code.1133;
            code.1225 = code.1224 + 1;
            code = code.1225;
            D.25756 = imb.b[1];
            *code.1224 = D.25756;
            code.1133 = code;
            code.1226 = code.1133;
            code.1227 = code.1226 + 1;
            code = code.1227;
            D.25759 = imb.b[2];
            *code.1226 = D.25759;
            code.1133 = code;
            code.1228 = code.1133;
            code.1229 = code.1228 + 1;
            code = code.1229;
            D.25762 = imb.b[3];
            *code.1228 = D.25762;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25763>;
      <D.25746>:
      if (1 != 0) goto <D.25764>; else goto <D.25765>;
      <D.25764>:
      D.25766 = (long unsigned int) stack_size;
      if (D.25766 == 18446744073709551608) goto <D.25767>; else goto <D.25768>;
      <D.25767>:
      code.1133 = code;
      code.1230 = code.1133;
      code.1231 = code.1230 + 1;
      code = code.1231;
      *code.1230 = 4;
      code.1133 = code;
      code.1232 = code.1133;
      code.1233 = code.1232 + 1;
      code = code.1233;
      *code.1232 = 36;
      goto <D.25773>;
      <D.25768>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25749 = stack_size.1135 + 8;
      D.25750 = (int) D.25749;
      if (D.25750 >= -128) goto <D.25776>; else goto <D.25774>;
      <D.25776>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25749 = stack_size.1135 + 8;
      D.25750 = (int) D.25749;
      if (D.25750 <= 127) goto <D.25777>; else goto <D.25774>;
      <D.25777>:
      code.1133 = code;
      code.1234 = code.1133;
      code.1235 = code.1234 + 1;
      code = code.1235;
      *code.1234 = 68;
      code.1133 = code;
      code.1236 = code.1133;
      code.1237 = code.1236 + 1;
      code = code.1237;
      *code.1236 = 36;
      code.1133 = code;
      D.25782 = (unsigned char) stack_size;
      D.25783 = D.25782 + 8;
      *code.1133 = D.25783;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25775>;
      <D.25774>:
      code.1133 = code;
      code.1238 = code.1133;
      code.1239 = code.1238 + 1;
      code = code.1239;
      *code.1238 = 132;
      code.1133 = code;
      code.1240 = code.1133;
      code.1241 = code.1240 + 1;
      code = code.1241;
      *code.1240 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            stack_size.1135 = (unsigned int) stack_size;
            D.25749 = stack_size.1135 + 8;
            D.25750 = (int) D.25749;
            imb.val = D.25750;
            code.1133 = code;
            code.1242 = code.1133;
            code.1243 = code.1242 + 1;
            code = code.1243;
            D.25790 = imb.b[0];
            *code.1242 = D.25790;
            code.1133 = code;
            code.1244 = code.1133;
            code.1245 = code.1244 + 1;
            code = code.1245;
            D.25793 = imb.b[1];
            *code.1244 = D.25793;
            code.1133 = code;
            code.1246 = code.1133;
            code.1247 = code.1246 + 1;
            code = code.1247;
            D.25796 = imb.b[2];
            *code.1246 = D.25796;
            code.1133 = code;
            code.1248 = code.1133;
            code.1249 = code.1248 + 1;
            code = code.1249;
            D.25799 = imb.b[3];
            *code.1248 = D.25799;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25775>:
      <D.25773>:
      goto <D.23118>;
      <D.25765>:
      D.25766 = (long unsigned int) stack_size;
      if (D.25766 == 18446744073709551608) goto <D.25800>; else goto <D.25801>;
      <D.25800>:
      code.1133 = code;
      code.1250 = code.1133;
      code.1251 = code.1250 + 1;
      code = code.1251;
      *code.1250 = 4;
      goto <D.23118>;
      <D.25801>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25749 = stack_size.1135 + 8;
      D.25750 = (int) D.25749;
      if (D.25750 >= -128) goto <D.25806>; else goto <D.25804>;
      <D.25806>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25749 = stack_size.1135 + 8;
      D.25750 = (int) D.25749;
      if (D.25750 <= 127) goto <D.25807>; else goto <D.25804>;
      <D.25807>:
      code.1133 = code;
      code.1252 = code.1133;
      code.1253 = code.1252 + 1;
      code = code.1253;
      *code.1252 = 68;
      code.1133 = code;
      D.25782 = (unsigned char) stack_size;
      D.25783 = D.25782 + 8;
      *code.1133 = D.25783;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25805>;
      <D.25804>:
      code.1133 = code;
      code.1254 = code.1133;
      code.1255 = code.1254 + 1;
      code = code.1255;
      *code.1254 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            stack_size.1135 = (unsigned int) stack_size;
            D.25749 = stack_size.1135 + 8;
            D.25750 = (int) D.25749;
            imb.val = D.25750;
            code.1133 = code;
            code.1256 = code.1133;
            code.1257 = code.1256 + 1;
            code = code.1257;
            D.25814 = imb.b[0];
            *code.1256 = D.25814;
            code.1133 = code;
            code.1258 = code.1133;
            code.1259 = code.1258 + 1;
            code = code.1259;
            D.25817 = imb.b[1];
            *code.1258 = D.25817;
            code.1133 = code;
            code.1260 = code.1133;
            code.1261 = code.1260 + 1;
            code = code.1261;
            D.25820 = imb.b[2];
            *code.1260 = D.25820;
            code.1133 = code;
            code.1262 = code.1133;
            code.1263 = code.1262 + 1;
            code = code.1263;
            D.25823 = imb.b[3];
            *code.1262 = D.25823;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25805>:
      <D.23118>:
      <D.25763>:
      if (0 != 0) goto <D.25824>; else goto <D.25825>;
      <D.25824>:
      code.1133 = code;
      code.1264 = code.1133;
      code.1265 = code.1264 + 1;
      code = code.1265;
      *code.1264 = 102;
      <D.25825>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25828>; else goto <D.25829>;
        <D.25828>:
        code.1133 = code;
        code.1266 = code.1133;
        code.1267 = code.1266 + 1;
        code = code.1267;
        D.25832 = _amd64_rex_bits | 64;
        *code.1266 = D.25832;
        <D.25829>:
      }
      switch (8) <default: <D.23126>, case 1: <D.23121>, case 2: <D.23123>, case 4: <D.23124>, case 8: <D.23125>>
      <D.23121>:
      code.1133 = code;
      code.1268 = code.1133;
      code.1269 = code.1268 + 1;
      code = code.1269;
      *code.1268 = 136;
      goto <D.23122>;
      <D.23123>:
      <D.23124>:
      <D.23125>:
      code.1133 = code;
      code.1270 = code.1133;
      code.1271 = code.1270 + 1;
      code = code.1271;
      *code.1270 = 137;
      goto <D.23122>;
      <D.23126>:
      __assert_fail ("0", "exceptions-amd64.c", 478, &__PRETTY_FUNCTION__);
      <D.23122>:
      if (1 != 0) goto <D.25837>; else goto <D.25838>;
      <D.25837>:
      D.25661 = (long unsigned int) regs_offset;
      if (D.25661 == 18446744073709551584) goto <D.25839>; else goto <D.25840>;
      <D.25839>:
      code.1133 = code;
      code.1272 = code.1133;
      code.1273 = code.1272 + 1;
      code = code.1273;
      *code.1272 = 4;
      code.1133 = code;
      code.1274 = code.1133;
      code.1275 = code.1274 + 1;
      code = code.1275;
      *code.1274 = 36;
      goto <D.25845>;
      <D.25840>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25848 = regs_offset.1185 + 32;
      D.25849 = (int) D.25848;
      if (D.25849 >= -128) goto <D.25850>; else goto <D.25846>;
      <D.25850>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25848 = regs_offset.1185 + 32;
      D.25849 = (int) D.25848;
      if (D.25849 <= 127) goto <D.25851>; else goto <D.25846>;
      <D.25851>:
      code.1133 = code;
      code.1276 = code.1133;
      code.1277 = code.1276 + 1;
      code = code.1277;
      *code.1276 = 68;
      code.1133 = code;
      code.1278 = code.1133;
      code.1279 = code.1278 + 1;
      code = code.1279;
      *code.1278 = 36;
      code.1133 = code;
      D.25692 = (unsigned char) regs_offset;
      D.25856 = D.25692 + 32;
      *code.1133 = D.25856;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25847>;
      <D.25846>:
      code.1133 = code;
      code.1280 = code.1133;
      code.1281 = code.1280 + 1;
      code = code.1281;
      *code.1280 = 132;
      code.1133 = code;
      code.1282 = code.1133;
      code.1283 = code.1282 + 1;
      code = code.1283;
      *code.1282 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            regs_offset.1185 = (unsigned int) regs_offset;
            D.25848 = regs_offset.1185 + 32;
            D.25849 = (int) D.25848;
            imb.val = D.25849;
            code.1133 = code;
            code.1284 = code.1133;
            code.1285 = code.1284 + 1;
            code = code.1285;
            D.25863 = imb.b[0];
            *code.1284 = D.25863;
            code.1133 = code;
            code.1286 = code.1133;
            code.1287 = code.1286 + 1;
            code = code.1287;
            D.25866 = imb.b[1];
            *code.1286 = D.25866;
            code.1133 = code;
            code.1288 = code.1133;
            code.1289 = code.1288 + 1;
            code = code.1289;
            D.25869 = imb.b[2];
            *code.1288 = D.25869;
            code.1133 = code;
            code.1290 = code.1133;
            code.1291 = code.1290 + 1;
            code = code.1291;
            D.25872 = imb.b[3];
            *code.1290 = D.25872;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25847>:
      <D.25845>:
      goto <D.23128>;
      <D.25838>:
      D.25661 = (long unsigned int) regs_offset;
      if (D.25661 == 18446744073709551584) goto <D.25873>; else goto <D.25874>;
      <D.25873>:
      code.1133 = code;
      code.1292 = code.1133;
      code.1293 = code.1292 + 1;
      code = code.1293;
      *code.1292 = 4;
      goto <D.23128>;
      <D.25874>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25848 = regs_offset.1185 + 32;
      D.25849 = (int) D.25848;
      if (D.25849 >= -128) goto <D.25879>; else goto <D.25877>;
      <D.25879>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25848 = regs_offset.1185 + 32;
      D.25849 = (int) D.25848;
      if (D.25849 <= 127) goto <D.25880>; else goto <D.25877>;
      <D.25880>:
      code.1133 = code;
      code.1294 = code.1133;
      code.1295 = code.1294 + 1;
      code = code.1295;
      *code.1294 = 68;
      code.1133 = code;
      D.25692 = (unsigned char) regs_offset;
      D.25856 = D.25692 + 32;
      *code.1133 = D.25856;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25878>;
      <D.25877>:
      code.1133 = code;
      code.1296 = code.1133;
      code.1297 = code.1296 + 1;
      code = code.1297;
      *code.1296 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            regs_offset.1185 = (unsigned int) regs_offset;
            D.25848 = regs_offset.1185 + 32;
            D.25849 = (int) D.25848;
            imb.val = D.25849;
            code.1133 = code;
            code.1298 = code.1133;
            code.1299 = code.1298 + 1;
            code = code.1299;
            D.25887 = imb.b[0];
            *code.1298 = D.25887;
            code.1133 = code;
            code.1300 = code.1133;
            code.1301 = code.1300 + 1;
            code = code.1301;
            D.25890 = imb.b[1];
            *code.1300 = D.25890;
            code.1133 = code;
            code.1302 = code.1133;
            code.1303 = code.1302 + 1;
            code = code.1303;
            D.25893 = imb.b[2];
            *code.1302 = D.25893;
            code.1133 = code;
            code.1304 = code.1133;
            code.1305 = code.1304 + 1;
            code = code.1305;
            D.25896 = imb.b[3];
            *code.1304 = D.25896;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25878>:
      <D.23128>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25897>; else goto <D.25898>;
        <D.25897>:
        code.1133 = code;
        code.1306 = code.1133;
        code.1307 = code.1306 + 1;
        code = code.1307;
        D.25901 = _amd64_rex_bits | 64;
        *code.1306 = D.25901;
        <D.25898>:
      }
      code.1133 = code;
      code.1308 = code.1133;
      code.1309 = code.1308 + 1;
      code = code.1309;
      *code.1308 = 141;
      if (0 != 0) goto <D.25904>; else goto <D.25905>;
      <D.25904>:
      code.1133 = code;
      code.1310 = code.1133;
      code.1311 = code.1310 + 1;
      code = code.1311;
      *code.1310 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = regs_offset;
            code.1133 = code;
            code.1312 = code.1133;
            code.1313 = code.1312 + 1;
            code = code.1313;
            D.25910 = imb.b[0];
            *code.1312 = D.25910;
            code.1133 = code;
            code.1314 = code.1133;
            code.1315 = code.1314 + 1;
            code = code.1315;
            D.25913 = imb.b[1];
            *code.1314 = D.25913;
            code.1133 = code;
            code.1316 = code.1133;
            code.1317 = code.1316 + 1;
            code = code.1317;
            D.25916 = imb.b[2];
            *code.1316 = D.25916;
            code.1133 = code;
            code.1318 = code.1133;
            code.1319 = code.1318 + 1;
            code = code.1319;
            D.25919 = imb.b[3];
            *code.1318 = D.25919;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.25920>;
      <D.25905>:
      if (1 != 0) goto <D.25921>; else goto <D.25922>;
      <D.25921>:
      if (regs_offset == 0) goto <D.25923>; else goto <D.25924>;
      <D.25923>:
      code.1133 = code;
      code.1320 = code.1133;
      code.1321 = code.1320 + 1;
      code = code.1321;
      *code.1320 = 4;
      code.1133 = code;
      code.1322 = code.1133;
      code.1323 = code.1322 + 1;
      code = code.1323;
      *code.1322 = 36;
      goto <D.25929>;
      <D.25924>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25930 = regs_offset.1185 + 128;
      if (D.25930 <= 255) goto <D.25931>; else goto <D.25932>;
      <D.25931>:
      code.1133 = code;
      code.1324 = code.1133;
      code.1325 = code.1324 + 1;
      code = code.1325;
      *code.1324 = 68;
      code.1133 = code;
      code.1326 = code.1133;
      code.1327 = code.1326 + 1;
      code = code.1327;
      *code.1326 = 36;
      code.1133 = code;
      D.25937 = (unsigned char) regs_offset;
      *code.1133 = D.25937;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25938>;
      <D.25932>:
      code.1133 = code;
      code.1328 = code.1133;
      code.1329 = code.1328 + 1;
      code = code.1329;
      *code.1328 = 132;
      code.1133 = code;
      code.1330 = code.1133;
      code.1331 = code.1330 + 1;
      code = code.1331;
      *code.1330 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = regs_offset;
            code.1133 = code;
            code.1332 = code.1133;
            code.1333 = code.1332 + 1;
            code = code.1333;
            D.25945 = imb.b[0];
            *code.1332 = D.25945;
            code.1133 = code;
            code.1334 = code.1133;
            code.1335 = code.1334 + 1;
            code = code.1335;
            D.25948 = imb.b[1];
            *code.1334 = D.25948;
            code.1133 = code;
            code.1336 = code.1133;
            code.1337 = code.1336 + 1;
            code = code.1337;
            D.25951 = imb.b[2];
            *code.1336 = D.25951;
            code.1133 = code;
            code.1338 = code.1133;
            code.1339 = code.1338 + 1;
            code = code.1339;
            D.25954 = imb.b[3];
            *code.1338 = D.25954;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25938>:
      <D.25929>:
      goto <D.23133>;
      <D.25922>:
      if (regs_offset == 0) goto <D.25955>; else goto <D.25956>;
      <D.25955>:
      code.1133 = code;
      code.1340 = code.1133;
      code.1341 = code.1340 + 1;
      code = code.1341;
      *code.1340 = 4;
      goto <D.23133>;
      <D.25956>:
      regs_offset.1185 = (unsigned int) regs_offset;
      D.25930 = regs_offset.1185 + 128;
      if (D.25930 <= 255) goto <D.25959>; else goto <D.25960>;
      <D.25959>:
      code.1133 = code;
      code.1342 = code.1133;
      code.1343 = code.1342 + 1;
      code = code.1343;
      *code.1342 = 68;
      code.1133 = code;
      D.25937 = (unsigned char) regs_offset;
      *code.1133 = D.25937;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.25963>;
      <D.25960>:
      code.1133 = code;
      code.1344 = code.1133;
      code.1345 = code.1344 + 1;
      code = code.1345;
      *code.1344 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = regs_offset;
            code.1133 = code;
            code.1346 = code.1133;
            code.1347 = code.1346 + 1;
            code = code.1347;
            D.25968 = imb.b[0];
            *code.1346 = D.25968;
            code.1133 = code;
            code.1348 = code.1133;
            code.1349 = code.1348 + 1;
            code = code.1349;
            D.25971 = imb.b[1];
            *code.1348 = D.25971;
            code.1133 = code;
            code.1350 = code.1133;
            code.1351 = code.1350 + 1;
            code = code.1351;
            D.25974 = imb.b[2];
            *code.1350 = D.25974;
            code.1133 = code;
            code.1352 = code.1133;
            code.1353 = code.1352 + 1;
            code = code.1353;
            D.25977 = imb.b[3];
            *code.1352 = D.25977;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.25963>:
      <D.23133>:
      <D.25920>:
      if (0 != 0) goto <D.25978>; else goto <D.25979>;
      <D.25978>:
      code.1133 = code;
      code.1354 = code.1133;
      code.1355 = code.1354 + 1;
      code = code.1355;
      *code.1354 = 102;
      <D.25979>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.25982>; else goto <D.25983>;
        <D.25982>:
        code.1133 = code;
        code.1356 = code.1133;
        code.1357 = code.1356 + 1;
        code = code.1357;
        D.25986 = _amd64_rex_bits | 64;
        *code.1356 = D.25986;
        <D.25983>:
      }
      switch (8) <default: <D.23141>, case 1: <D.23136>, case 2: <D.23138>, case 4: <D.23139>, case 8: <D.23140>>
      <D.23136>:
      code.1133 = code;
      code.1358 = code.1133;
      code.1359 = code.1358 + 1;
      code = code.1359;
      *code.1358 = 136;
      goto <D.23137>;
      <D.23138>:
      <D.23139>:
      <D.23140>:
      code.1133 = code;
      code.1360 = code.1133;
      code.1361 = code.1360 + 1;
      code = code.1361;
      *code.1360 = 137;
      goto <D.23137>;
      <D.23141>:
      __assert_fail ("0", "exceptions-amd64.c", 481, &__PRETTY_FUNCTION__);
      <D.23137>:
      if (1 != 0) goto <D.25991>; else goto <D.25992>;
      <D.25991>:
      D.25993 = arg_offsets[0];
      if (D.25993 == 0) goto <D.25994>; else goto <D.25995>;
      <D.25994>:
      code.1133 = code;
      code.1362 = code.1133;
      code.1363 = code.1362 + 1;
      code = code.1363;
      *code.1362 = 4;
      code.1133 = code;
      code.1364 = code.1133;
      code.1365 = code.1364 + 1;
      code = code.1365;
      *code.1364 = 36;
      goto <D.26000>;
      <D.25995>:
      D.25993 = arg_offsets[0];
      D.26001 = (unsigned int) D.25993;
      D.26002 = D.26001 + 128;
      if (D.26002 <= 255) goto <D.26003>; else goto <D.26004>;
      <D.26003>:
      code.1133 = code;
      code.1366 = code.1133;
      code.1367 = code.1366 + 1;
      code = code.1367;
      *code.1366 = 68;
      code.1133 = code;
      code.1368 = code.1133;
      code.1369 = code.1368 + 1;
      code = code.1369;
      *code.1368 = 36;
      code.1133 = code;
      D.25993 = arg_offsets[0];
      D.26009 = (unsigned char) D.25993;
      *code.1133 = D.26009;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26010>;
      <D.26004>:
      code.1133 = code;
      code.1370 = code.1133;
      code.1371 = code.1370 + 1;
      code = code.1371;
      *code.1370 = 132;
      code.1133 = code;
      code.1372 = code.1133;
      code.1373 = code.1372 + 1;
      code = code.1373;
      *code.1372 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.25993 = arg_offsets[0];
            imb.val = D.25993;
            code.1133 = code;
            code.1374 = code.1133;
            code.1375 = code.1374 + 1;
            code = code.1375;
            D.26017 = imb.b[0];
            *code.1374 = D.26017;
            code.1133 = code;
            code.1376 = code.1133;
            code.1377 = code.1376 + 1;
            code = code.1377;
            D.26020 = imb.b[1];
            *code.1376 = D.26020;
            code.1133 = code;
            code.1378 = code.1133;
            code.1379 = code.1378 + 1;
            code = code.1379;
            D.26023 = imb.b[2];
            *code.1378 = D.26023;
            code.1133 = code;
            code.1380 = code.1133;
            code.1381 = code.1380 + 1;
            code = code.1381;
            D.26026 = imb.b[3];
            *code.1380 = D.26026;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26010>:
      <D.26000>:
      goto <D.23143>;
      <D.25992>:
      D.25993 = arg_offsets[0];
      if (D.25993 == 0) goto <D.26027>; else goto <D.26028>;
      <D.26027>:
      code.1133 = code;
      code.1382 = code.1133;
      code.1383 = code.1382 + 1;
      code = code.1383;
      *code.1382 = 4;
      goto <D.23143>;
      <D.26028>:
      D.25993 = arg_offsets[0];
      D.26001 = (unsigned int) D.25993;
      D.26002 = D.26001 + 128;
      if (D.26002 <= 255) goto <D.26031>; else goto <D.26032>;
      <D.26031>:
      code.1133 = code;
      code.1384 = code.1133;
      code.1385 = code.1384 + 1;
      code = code.1385;
      *code.1384 = 68;
      code.1133 = code;
      D.25993 = arg_offsets[0];
      D.26009 = (unsigned char) D.25993;
      *code.1133 = D.26009;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26035>;
      <D.26032>:
      code.1133 = code;
      code.1386 = code.1133;
      code.1387 = code.1386 + 1;
      code = code.1387;
      *code.1386 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.25993 = arg_offsets[0];
            imb.val = D.25993;
            code.1133 = code;
            code.1388 = code.1133;
            code.1389 = code.1388 + 1;
            code = code.1389;
            D.26040 = imb.b[0];
            *code.1388 = D.26040;
            code.1133 = code;
            code.1390 = code.1133;
            code.1391 = code.1390 + 1;
            code = code.1391;
            D.26043 = imb.b[1];
            *code.1390 = D.26043;
            code.1133 = code;
            code.1392 = code.1133;
            code.1393 = code.1392 + 1;
            code = code.1393;
            D.26046 = imb.b[2];
            *code.1392 = D.26046;
            code.1133 = code;
            code.1394 = code.1133;
            code.1395 = code.1394 + 1;
            code = code.1395;
            D.26049 = imb.b[3];
            *code.1394 = D.26049;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26035>:
      <D.23143>:
      if (llvm_abs != 0) goto <D.26050>; else goto <D.26051>;
      <D.26050>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26052>; else goto <D.26053>;
        <D.26052>:
        code.1133 = code;
        code.1396 = code.1133;
        code.1397 = code.1396 + 1;
        code = code.1397;
        D.26056 = _amd64_rex_bits | 64;
        *code.1396 = D.26056;
        <D.26053>:
      }
      code.1133 = code;
      code.1398 = code.1133;
      code.1399 = code.1398 + 1;
      code = code.1399;
      *code.1398 = 51;
      code.1133 = code;
      code.1400 = code.1133;
      code.1401 = code.1400 + 1;
      code = code.1401;
      *code.1400 = 192;
      goto <D.26061>;
      <D.26051>:
      if (0 != 0) goto <D.26062>; else goto <D.26063>;
      <D.26062>:
      code.1133 = code;
      code.1402 = code.1133;
      code.1403 = code.1402 + 1;
      code = code.1403;
      *code.1402 = 102;
      <D.26063>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26066>; else goto <D.26067>;
        <D.26066>:
        code.1133 = code;
        code.1404 = code.1133;
        code.1405 = code.1404 + 1;
        code = code.1405;
        D.26070 = _amd64_rex_bits | 64;
        *code.1404 = D.26070;
        <D.26067>:
      }
      switch (8) <default: <D.23152>, case 1: <D.23147>, case 2: <D.23149>, case 4: <D.23150>, case 8: <D.23151>>
      <D.23147>:
      code.1133 = code;
      code.1406 = code.1133;
      code.1407 = code.1406 + 1;
      code = code.1407;
      *code.1406 = 138;
      goto <D.23148>;
      <D.23149>:
      <D.23150>:
      <D.23151>:
      code.1133 = code;
      code.1408 = code.1133;
      code.1409 = code.1408 + 1;
      code = code.1409;
      *code.1408 = 139;
      goto <D.23148>;
      <D.23152>:
      __assert_fail ("0", "exceptions-amd64.c", 486, &__PRETTY_FUNCTION__);
      <D.23148>:
      if (0 != 0) goto <D.26075>; else goto <D.26076>;
      <D.26075>:
      code.1133 = code;
      code.1410 = code.1133;
      code.1411 = code.1410 + 1;
      code = code.1411;
      *code.1410 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = stack_size;
            code.1133 = code;
            code.1412 = code.1133;
            code.1413 = code.1412 + 1;
            code = code.1413;
            D.26081 = imb.b[0];
            *code.1412 = D.26081;
            code.1133 = code;
            code.1414 = code.1133;
            code.1415 = code.1414 + 1;
            code = code.1415;
            D.26084 = imb.b[1];
            *code.1414 = D.26084;
            code.1133 = code;
            code.1416 = code.1133;
            code.1417 = code.1416 + 1;
            code = code.1417;
            D.26087 = imb.b[2];
            *code.1416 = D.26087;
            code.1133 = code;
            code.1418 = code.1133;
            code.1419 = code.1418 + 1;
            code = code.1419;
            D.26090 = imb.b[3];
            *code.1418 = D.26090;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.26091>;
      <D.26076>:
      if (1 != 0) goto <D.26092>; else goto <D.26093>;
      <D.26092>:
      if (stack_size == 0) goto <D.26094>; else goto <D.26095>;
      <D.26094>:
      code.1133 = code;
      code.1420 = code.1133;
      code.1421 = code.1420 + 1;
      code = code.1421;
      *code.1420 = 4;
      code.1133 = code;
      code.1422 = code.1133;
      code.1423 = code.1422 + 1;
      code = code.1423;
      *code.1422 = 36;
      goto <D.26100>;
      <D.26095>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25566 = stack_size.1135 + 128;
      if (D.25566 <= 255) goto <D.26101>; else goto <D.26102>;
      <D.26101>:
      code.1133 = code;
      code.1424 = code.1133;
      code.1425 = code.1424 + 1;
      code = code.1425;
      *code.1424 = 68;
      code.1133 = code;
      code.1426 = code.1133;
      code.1427 = code.1426 + 1;
      code = code.1427;
      *code.1426 = 36;
      code.1133 = code;
      D.25578 = (unsigned char) stack_size;
      *code.1133 = D.25578;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26107>;
      <D.26102>:
      code.1133 = code;
      code.1428 = code.1133;
      code.1429 = code.1428 + 1;
      code = code.1429;
      *code.1428 = 132;
      code.1133 = code;
      code.1430 = code.1133;
      code.1431 = code.1430 + 1;
      code = code.1431;
      *code.1430 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = stack_size;
            code.1133 = code;
            code.1432 = code.1133;
            code.1433 = code.1432 + 1;
            code = code.1433;
            D.26114 = imb.b[0];
            *code.1432 = D.26114;
            code.1133 = code;
            code.1434 = code.1133;
            code.1435 = code.1434 + 1;
            code = code.1435;
            D.26117 = imb.b[1];
            *code.1434 = D.26117;
            code.1133 = code;
            code.1436 = code.1133;
            code.1437 = code.1436 + 1;
            code = code.1437;
            D.26120 = imb.b[2];
            *code.1436 = D.26120;
            code.1133 = code;
            code.1438 = code.1133;
            code.1439 = code.1438 + 1;
            code = code.1439;
            D.26123 = imb.b[3];
            *code.1438 = D.26123;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26107>:
      <D.26100>:
      goto <D.23155>;
      <D.26093>:
      if (stack_size == 0) goto <D.26124>; else goto <D.26125>;
      <D.26124>:
      code.1133 = code;
      code.1440 = code.1133;
      code.1441 = code.1440 + 1;
      code = code.1441;
      *code.1440 = 4;
      goto <D.23155>;
      <D.26125>:
      stack_size.1135 = (unsigned int) stack_size;
      D.25566 = stack_size.1135 + 128;
      if (D.25566 <= 255) goto <D.26128>; else goto <D.26129>;
      <D.26128>:
      code.1133 = code;
      code.1442 = code.1133;
      code.1443 = code.1442 + 1;
      code = code.1443;
      *code.1442 = 68;
      code.1133 = code;
      D.25578 = (unsigned char) stack_size;
      *code.1133 = D.25578;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26132>;
      <D.26129>:
      code.1133 = code;
      code.1444 = code.1133;
      code.1445 = code.1444 + 1;
      code = code.1445;
      *code.1444 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = stack_size;
            code.1133 = code;
            code.1446 = code.1133;
            code.1447 = code.1446 + 1;
            code = code.1447;
            D.26137 = imb.b[0];
            *code.1446 = D.26137;
            code.1133 = code;
            code.1448 = code.1133;
            code.1449 = code.1448 + 1;
            code = code.1449;
            D.26140 = imb.b[1];
            *code.1448 = D.26140;
            code.1133 = code;
            code.1450 = code.1133;
            code.1451 = code.1450 + 1;
            code = code.1451;
            D.26143 = imb.b[2];
            *code.1450 = D.26143;
            code.1133 = code;
            code.1452 = code.1133;
            code.1453 = code.1452 + 1;
            code = code.1453;
            D.26146 = imb.b[3];
            *code.1452 = D.26146;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26132>:
      <D.23155>:
      <D.26091>:
      <D.26061>:
      if (0 != 0) goto <D.26147>; else goto <D.26148>;
      <D.26147>:
      code.1133 = code;
      code.1454 = code.1133;
      code.1455 = code.1454 + 1;
      code = code.1455;
      *code.1454 = 102;
      <D.26148>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26151>; else goto <D.26152>;
        <D.26151>:
        code.1133 = code;
        code.1456 = code.1133;
        code.1457 = code.1456 + 1;
        code = code.1457;
        D.26155 = _amd64_rex_bits | 64;
        *code.1456 = D.26155;
        <D.26152>:
      }
      switch (8) <default: <D.23163>, case 1: <D.23158>, case 2: <D.23160>, case 4: <D.23161>, case 8: <D.23162>>
      <D.23158>:
      code.1133 = code;
      code.1458 = code.1133;
      code.1459 = code.1458 + 1;
      code = code.1459;
      *code.1458 = 136;
      goto <D.23159>;
      <D.23160>:
      <D.23161>:
      <D.23162>:
      code.1133 = code;
      code.1460 = code.1133;
      code.1461 = code.1460 + 1;
      code = code.1461;
      *code.1460 = 137;
      goto <D.23159>;
      <D.23163>:
      __assert_fail ("0", "exceptions-amd64.c", 487, &__PRETTY_FUNCTION__);
      <D.23159>:
      if (1 != 0) goto <D.26160>; else goto <D.26161>;
      <D.26160>:
      D.26162 = arg_offsets[1];
      if (D.26162 == 0) goto <D.26163>; else goto <D.26164>;
      <D.26163>:
      code.1133 = code;
      code.1462 = code.1133;
      code.1463 = code.1462 + 1;
      code = code.1463;
      *code.1462 = 4;
      code.1133 = code;
      code.1464 = code.1133;
      code.1465 = code.1464 + 1;
      code = code.1465;
      *code.1464 = 36;
      goto <D.26169>;
      <D.26164>:
      D.26162 = arg_offsets[1];
      D.26170 = (unsigned int) D.26162;
      D.26171 = D.26170 + 128;
      if (D.26171 <= 255) goto <D.26172>; else goto <D.26173>;
      <D.26172>:
      code.1133 = code;
      code.1466 = code.1133;
      code.1467 = code.1466 + 1;
      code = code.1467;
      *code.1466 = 68;
      code.1133 = code;
      code.1468 = code.1133;
      code.1469 = code.1468 + 1;
      code = code.1469;
      *code.1468 = 36;
      code.1133 = code;
      D.26162 = arg_offsets[1];
      D.26178 = (unsigned char) D.26162;
      *code.1133 = D.26178;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26179>;
      <D.26173>:
      code.1133 = code;
      code.1470 = code.1133;
      code.1471 = code.1470 + 1;
      code = code.1471;
      *code.1470 = 132;
      code.1133 = code;
      code.1472 = code.1133;
      code.1473 = code.1472 + 1;
      code = code.1473;
      *code.1472 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26162 = arg_offsets[1];
            imb.val = D.26162;
            code.1133 = code;
            code.1474 = code.1133;
            code.1475 = code.1474 + 1;
            code = code.1475;
            D.26186 = imb.b[0];
            *code.1474 = D.26186;
            code.1133 = code;
            code.1476 = code.1133;
            code.1477 = code.1476 + 1;
            code = code.1477;
            D.26189 = imb.b[1];
            *code.1476 = D.26189;
            code.1133 = code;
            code.1478 = code.1133;
            code.1479 = code.1478 + 1;
            code = code.1479;
            D.26192 = imb.b[2];
            *code.1478 = D.26192;
            code.1133 = code;
            code.1480 = code.1133;
            code.1481 = code.1480 + 1;
            code = code.1481;
            D.26195 = imb.b[3];
            *code.1480 = D.26195;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26179>:
      <D.26169>:
      goto <D.23165>;
      <D.26161>:
      D.26162 = arg_offsets[1];
      if (D.26162 == 0) goto <D.26196>; else goto <D.26197>;
      <D.26196>:
      code.1133 = code;
      code.1482 = code.1133;
      code.1483 = code.1482 + 1;
      code = code.1483;
      *code.1482 = 4;
      goto <D.23165>;
      <D.26197>:
      D.26162 = arg_offsets[1];
      D.26170 = (unsigned int) D.26162;
      D.26171 = D.26170 + 128;
      if (D.26171 <= 255) goto <D.26200>; else goto <D.26201>;
      <D.26200>:
      code.1133 = code;
      code.1484 = code.1133;
      code.1485 = code.1484 + 1;
      code = code.1485;
      *code.1484 = 68;
      code.1133 = code;
      D.26162 = arg_offsets[1];
      D.26178 = (unsigned char) D.26162;
      *code.1133 = D.26178;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26204>;
      <D.26201>:
      code.1133 = code;
      code.1486 = code.1133;
      code.1487 = code.1486 + 1;
      code = code.1487;
      *code.1486 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26162 = arg_offsets[1];
            imb.val = D.26162;
            code.1133 = code;
            code.1488 = code.1133;
            code.1489 = code.1488 + 1;
            code = code.1489;
            D.26209 = imb.b[0];
            *code.1488 = D.26209;
            code.1133 = code;
            code.1490 = code.1133;
            code.1491 = code.1490 + 1;
            code = code.1491;
            D.26212 = imb.b[1];
            *code.1490 = D.26212;
            code.1133 = code;
            code.1492 = code.1133;
            code.1493 = code.1492 + 1;
            code = code.1493;
            D.26215 = imb.b[2];
            *code.1492 = D.26215;
            code.1133 = code;
            code.1494 = code.1133;
            code.1495 = code.1494 + 1;
            code = code.1495;
            D.26218 = imb.b[3];
            *code.1494 = D.26218;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26204>:
      <D.23165>:
      if (resume_unwind != 0) goto <D.26219>; else goto <D.26220>;
      <D.26219>:
      if (0 != 0) goto <D.26221>; else goto <D.26222>;
      <D.26221>:
      code.1133 = code;
      code.1496 = code.1133;
      code.1497 = code.1496 + 1;
      code = code.1497;
      *code.1496 = 102;
      <D.26222>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26225>; else goto <D.26226>;
        <D.26225>:
        code.1133 = code;
        code.1498 = code.1133;
        code.1499 = code.1498 + 1;
        code = code.1499;
        D.26229 = _amd64_rex_bits | 64;
        *code.1498 = D.26229;
        <D.26226>:
      }
      if (0 != 0) goto <D.26230>; else goto <D.26231>;
      <D.26230>:
      code.1133 = code;
      code.1500 = code.1133;
      code.1501 = code.1500 + 1;
      code = code.1501;
      *code.1500 = 198;
      if (1 != 0) goto <D.26234>; else goto <D.26235>;
      <D.26234>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26237>; else goto <D.26238>;
      <D.26237>:
      code.1133 = code;
      code.1502 = code.1133;
      code.1503 = code.1502 + 1;
      code = code.1503;
      *code.1502 = 4;
      code.1133 = code;
      code.1504 = code.1133;
      code.1505 = code.1504 + 1;
      code = code.1505;
      *code.1504 = 36;
      goto <D.26243>;
      <D.26238>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26246>; else goto <D.26247>;
      <D.26246>:
      code.1133 = code;
      code.1506 = code.1133;
      code.1507 = code.1506 + 1;
      code = code.1507;
      *code.1506 = 68;
      code.1133 = code;
      code.1508 = code.1133;
      code.1509 = code.1508 + 1;
      code = code.1509;
      *code.1508 = 36;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26253>;
      <D.26247>:
      code.1133 = code;
      code.1510 = code.1133;
      code.1511 = code.1510 + 1;
      code = code.1511;
      *code.1510 = 132;
      code.1133 = code;
      code.1512 = code.1133;
      code.1513 = code.1512 + 1;
      code = code.1513;
      *code.1512 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1514 = code.1133;
            code.1515 = code.1514 + 1;
            code = code.1515;
            D.26260 = imb.b[0];
            *code.1514 = D.26260;
            code.1133 = code;
            code.1516 = code.1133;
            code.1517 = code.1516 + 1;
            code = code.1517;
            D.26263 = imb.b[1];
            *code.1516 = D.26263;
            code.1133 = code;
            code.1518 = code.1133;
            code.1519 = code.1518 + 1;
            code = code.1519;
            D.26266 = imb.b[2];
            *code.1518 = D.26266;
            code.1133 = code;
            code.1520 = code.1133;
            code.1521 = code.1520 + 1;
            code = code.1521;
            D.26269 = imb.b[3];
            *code.1520 = D.26269;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26253>:
      <D.26243>:
      goto <D.23169>;
      <D.26235>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26270>; else goto <D.26271>;
      <D.26270>:
      code.1133 = code;
      code.1522 = code.1133;
      code.1523 = code.1522 + 1;
      code = code.1523;
      *code.1522 = 4;
      goto <D.23169>;
      <D.26271>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26274>; else goto <D.26275>;
      <D.26274>:
      code.1133 = code;
      code.1524 = code.1133;
      code.1525 = code.1524 + 1;
      code = code.1525;
      *code.1524 = 68;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26278>;
      <D.26275>:
      code.1133 = code;
      code.1526 = code.1133;
      code.1527 = code.1526 + 1;
      code = code.1527;
      *code.1526 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1528 = code.1133;
            code.1529 = code.1528 + 1;
            code = code.1529;
            D.26283 = imb.b[0];
            *code.1528 = D.26283;
            code.1133 = code;
            code.1530 = code.1133;
            code.1531 = code.1530 + 1;
            code = code.1531;
            D.26286 = imb.b[1];
            *code.1530 = D.26286;
            code.1133 = code;
            code.1532 = code.1133;
            code.1533 = code.1532 + 1;
            code = code.1533;
            D.26289 = imb.b[2];
            *code.1532 = D.26289;
            code.1133 = code;
            code.1534 = code.1133;
            code.1535 = code.1534 + 1;
            code = code.1535;
            D.26292 = imb.b[3];
            *code.1534 = D.26292;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26278>:
      <D.23169>:
      code.1133 = code;
      *code.1133 = 0;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26293>;
      <D.26231>:
      if (0 != 0) goto <D.26294>; else goto <D.26295>;
      <D.26294>:
      code.1133 = code;
      code.1536 = code.1133;
      code.1537 = code.1536 + 1;
      code = code.1537;
      *code.1536 = 199;
      if (1 != 0) goto <D.26298>; else goto <D.26299>;
      <D.26298>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26300>; else goto <D.26301>;
      <D.26300>:
      code.1133 = code;
      code.1538 = code.1133;
      code.1539 = code.1538 + 1;
      code = code.1539;
      *code.1538 = 4;
      code.1133 = code;
      code.1540 = code.1133;
      code.1541 = code.1540 + 1;
      code = code.1541;
      *code.1540 = 36;
      goto <D.26306>;
      <D.26301>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26307>; else goto <D.26308>;
      <D.26307>:
      code.1133 = code;
      code.1542 = code.1133;
      code.1543 = code.1542 + 1;
      code = code.1543;
      *code.1542 = 68;
      code.1133 = code;
      code.1544 = code.1133;
      code.1545 = code.1544 + 1;
      code = code.1545;
      *code.1544 = 36;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26313>;
      <D.26308>:
      code.1133 = code;
      code.1546 = code.1133;
      code.1547 = code.1546 + 1;
      code = code.1547;
      *code.1546 = 132;
      code.1133 = code;
      code.1548 = code.1133;
      code.1549 = code.1548 + 1;
      code = code.1549;
      *code.1548 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1550 = code.1133;
            code.1551 = code.1550 + 1;
            code = code.1551;
            D.26320 = imb.b[0];
            *code.1550 = D.26320;
            code.1133 = code;
            code.1552 = code.1133;
            code.1553 = code.1552 + 1;
            code = code.1553;
            D.26323 = imb.b[1];
            *code.1552 = D.26323;
            code.1133 = code;
            code.1554 = code.1133;
            code.1555 = code.1554 + 1;
            code = code.1555;
            D.26326 = imb.b[2];
            *code.1554 = D.26326;
            code.1133 = code;
            code.1556 = code.1133;
            code.1557 = code.1556 + 1;
            code = code.1557;
            D.26329 = imb.b[3];
            *code.1556 = D.26329;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26313>:
      <D.26306>:
      goto <D.23172>;
      <D.26299>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26330>; else goto <D.26331>;
      <D.26330>:
      code.1133 = code;
      code.1558 = code.1133;
      code.1559 = code.1558 + 1;
      code = code.1559;
      *code.1558 = 4;
      goto <D.23172>;
      <D.26331>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26334>; else goto <D.26335>;
      <D.26334>:
      code.1133 = code;
      code.1560 = code.1133;
      code.1561 = code.1560 + 1;
      code = code.1561;
      *code.1560 = 68;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26338>;
      <D.26335>:
      code.1133 = code;
      code.1562 = code.1133;
      code.1563 = code.1562 + 1;
      code = code.1563;
      *code.1562 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1564 = code.1133;
            code.1565 = code.1564 + 1;
            code = code.1565;
            D.26343 = imb.b[0];
            *code.1564 = D.26343;
            code.1133 = code;
            code.1566 = code.1133;
            code.1567 = code.1566 + 1;
            code = code.1567;
            D.26346 = imb.b[1];
            *code.1566 = D.26346;
            code.1133 = code;
            code.1568 = code.1133;
            code.1569 = code.1568 + 1;
            code = code.1569;
            D.26349 = imb.b[2];
            *code.1568 = D.26349;
            code.1133 = code;
            code.1570 = code.1133;
            code.1571 = code.1570 + 1;
            code = code.1571;
            D.26352 = imb.b[3];
            *code.1570 = D.26352;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26338>:
      <D.23172>:
      code.1133 = code;
      MEM[(short int *)code.1133] = 0;
      code.1133 = code;
      code.1572 = code.1133 + 2;
      code = code.1572;
      goto <D.26354>;
      <D.26295>:
      code.1133 = code;
      code.1573 = code.1133;
      code.1574 = code.1573 + 1;
      code = code.1574;
      *code.1573 = 199;
      if (1 != 0) goto <D.26357>; else goto <D.26358>;
      <D.26357>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26359>; else goto <D.26360>;
      <D.26359>:
      code.1133 = code;
      code.1575 = code.1133;
      code.1576 = code.1575 + 1;
      code = code.1576;
      *code.1575 = 4;
      code.1133 = code;
      code.1577 = code.1133;
      code.1578 = code.1577 + 1;
      code = code.1578;
      *code.1577 = 36;
      goto <D.26365>;
      <D.26360>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26366>; else goto <D.26367>;
      <D.26366>:
      code.1133 = code;
      code.1579 = code.1133;
      code.1580 = code.1579 + 1;
      code = code.1580;
      *code.1579 = 68;
      code.1133 = code;
      code.1581 = code.1133;
      code.1582 = code.1581 + 1;
      code = code.1582;
      *code.1581 = 36;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26372>;
      <D.26367>:
      code.1133 = code;
      code.1583 = code.1133;
      code.1584 = code.1583 + 1;
      code = code.1584;
      *code.1583 = 132;
      code.1133 = code;
      code.1585 = code.1133;
      code.1586 = code.1585 + 1;
      code = code.1586;
      *code.1585 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1587 = code.1133;
            code.1588 = code.1587 + 1;
            code = code.1588;
            D.26379 = imb.b[0];
            *code.1587 = D.26379;
            code.1133 = code;
            code.1589 = code.1133;
            code.1590 = code.1589 + 1;
            code = code.1590;
            D.26382 = imb.b[1];
            *code.1589 = D.26382;
            code.1133 = code;
            code.1591 = code.1133;
            code.1592 = code.1591 + 1;
            code = code.1592;
            D.26385 = imb.b[2];
            *code.1591 = D.26385;
            code.1133 = code;
            code.1593 = code.1133;
            code.1594 = code.1593 + 1;
            code = code.1594;
            D.26388 = imb.b[3];
            *code.1593 = D.26388;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26372>:
      <D.26365>:
      goto <D.23175>;
      <D.26358>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26389>; else goto <D.26390>;
      <D.26389>:
      code.1133 = code;
      code.1595 = code.1133;
      code.1596 = code.1595 + 1;
      code = code.1596;
      *code.1595 = 4;
      goto <D.23175>;
      <D.26390>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26393>; else goto <D.26394>;
      <D.26393>:
      code.1133 = code;
      code.1597 = code.1133;
      code.1598 = code.1597 + 1;
      code = code.1598;
      *code.1597 = 68;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26397>;
      <D.26394>:
      code.1133 = code;
      code.1599 = code.1133;
      code.1600 = code.1599 + 1;
      code = code.1600;
      *code.1599 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1601 = code.1133;
            code.1602 = code.1601 + 1;
            code = code.1602;
            D.26402 = imb.b[0];
            *code.1601 = D.26402;
            code.1133 = code;
            code.1603 = code.1133;
            code.1604 = code.1603 + 1;
            code = code.1604;
            D.26405 = imb.b[1];
            *code.1603 = D.26405;
            code.1133 = code;
            code.1605 = code.1133;
            code.1606 = code.1605 + 1;
            code = code.1606;
            D.26408 = imb.b[2];
            *code.1605 = D.26408;
            code.1133 = code;
            code.1607 = code.1133;
            code.1608 = code.1607 + 1;
            code = code.1608;
            D.26411 = imb.b[3];
            *code.1607 = D.26411;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26397>:
      <D.23175>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1133 = code;
            code.1609 = code.1133;
            code.1610 = code.1609 + 1;
            code = code.1610;
            D.26414 = imb.b[0];
            *code.1609 = D.26414;
            code.1133 = code;
            code.1611 = code.1133;
            code.1612 = code.1611 + 1;
            code = code.1612;
            D.26417 = imb.b[1];
            *code.1611 = D.26417;
            code.1133 = code;
            code.1613 = code.1133;
            code.1614 = code.1613 + 1;
            code = code.1614;
            D.26420 = imb.b[2];
            *code.1613 = D.26420;
            code.1133 = code;
            code.1615 = code.1133;
            code.1616 = code.1615 + 1;
            code = code.1616;
            D.26423 = imb.b[3];
            *code.1615 = D.26423;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26354>:
      <D.26293>:
      goto <D.26424>;
      <D.26220>:
      if (0 != 0) goto <D.26425>; else goto <D.26426>;
      <D.26425>:
      code.1133 = code;
      code.1617 = code.1133;
      code.1618 = code.1617 + 1;
      code = code.1618;
      *code.1617 = 102;
      <D.26426>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26429>; else goto <D.26430>;
        <D.26429>:
        code.1133 = code;
        code.1619 = code.1133;
        code.1620 = code.1619 + 1;
        code = code.1620;
        D.26433 = _amd64_rex_bits | 64;
        *code.1619 = D.26433;
        <D.26430>:
      }
      switch (8) <default: <D.23184>, case 1: <D.23179>, case 2: <D.23181>, case 4: <D.23182>, case 8: <D.23183>>
      <D.23179>:
      code.1133 = code;
      code.1621 = code.1133;
      code.1622 = code.1621 + 1;
      code = code.1622;
      *code.1621 = 136;
      goto <D.23180>;
      <D.23181>:
      <D.23182>:
      <D.23183>:
      code.1133 = code;
      code.1623 = code.1133;
      code.1624 = code.1623 + 1;
      code = code.1624;
      *code.1623 = 137;
      goto <D.23180>;
      <D.23184>:
      __assert_fail ("0", "exceptions-amd64.c", 492, &__PRETTY_FUNCTION__);
      <D.23180>:
      if (1 != 0) goto <D.26438>; else goto <D.26439>;
      <D.26438>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26440>; else goto <D.26441>;
      <D.26440>:
      code.1133 = code;
      code.1625 = code.1133;
      code.1626 = code.1625 + 1;
      code = code.1626;
      *code.1625 = 60;
      code.1133 = code;
      code.1627 = code.1133;
      code.1628 = code.1627 + 1;
      code = code.1628;
      *code.1627 = 36;
      goto <D.26446>;
      <D.26441>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26447>; else goto <D.26448>;
      <D.26447>:
      code.1133 = code;
      code.1629 = code.1133;
      code.1630 = code.1629 + 1;
      code = code.1630;
      *code.1629 = 124;
      code.1133 = code;
      code.1631 = code.1133;
      code.1632 = code.1631 + 1;
      code = code.1632;
      *code.1631 = 36;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26453>;
      <D.26448>:
      code.1133 = code;
      code.1633 = code.1133;
      code.1634 = code.1633 + 1;
      code = code.1634;
      *code.1633 = 188;
      code.1133 = code;
      code.1635 = code.1133;
      code.1636 = code.1635 + 1;
      code = code.1636;
      *code.1635 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1637 = code.1133;
            code.1638 = code.1637 + 1;
            code = code.1638;
            D.26460 = imb.b[0];
            *code.1637 = D.26460;
            code.1133 = code;
            code.1639 = code.1133;
            code.1640 = code.1639 + 1;
            code = code.1640;
            D.26463 = imb.b[1];
            *code.1639 = D.26463;
            code.1133 = code;
            code.1641 = code.1133;
            code.1642 = code.1641 + 1;
            code = code.1642;
            D.26466 = imb.b[2];
            *code.1641 = D.26466;
            code.1133 = code;
            code.1643 = code.1133;
            code.1644 = code.1643 + 1;
            code = code.1644;
            D.26469 = imb.b[3];
            *code.1643 = D.26469;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26453>:
      <D.26446>:
      goto <D.23186>;
      <D.26439>:
      D.26236 = arg_offsets[2];
      if (D.26236 == 0) goto <D.26470>; else goto <D.26471>;
      <D.26470>:
      code.1133 = code;
      code.1645 = code.1133;
      code.1646 = code.1645 + 1;
      code = code.1646;
      *code.1645 = 60;
      goto <D.23186>;
      <D.26471>:
      D.26236 = arg_offsets[2];
      D.26244 = (unsigned int) D.26236;
      D.26245 = D.26244 + 128;
      if (D.26245 <= 255) goto <D.26474>; else goto <D.26475>;
      <D.26474>:
      code.1133 = code;
      code.1647 = code.1133;
      code.1648 = code.1647 + 1;
      code = code.1648;
      *code.1647 = 124;
      code.1133 = code;
      D.26236 = arg_offsets[2];
      D.26252 = (unsigned char) D.26236;
      *code.1133 = D.26252;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26478>;
      <D.26475>:
      code.1133 = code;
      code.1649 = code.1133;
      code.1650 = code.1649 + 1;
      code = code.1650;
      *code.1649 = 188;
      {
        union x86_imm_buf imb;

        try
          {
            D.26236 = arg_offsets[2];
            imb.val = D.26236;
            code.1133 = code;
            code.1651 = code.1133;
            code.1652 = code.1651 + 1;
            code = code.1652;
            D.26483 = imb.b[0];
            *code.1651 = D.26483;
            code.1133 = code;
            code.1653 = code.1133;
            code.1654 = code.1653 + 1;
            code = code.1654;
            D.26486 = imb.b[1];
            *code.1653 = D.26486;
            code.1133 = code;
            code.1655 = code.1133;
            code.1656 = code.1655 + 1;
            code = code.1656;
            D.26489 = imb.b[2];
            *code.1655 = D.26489;
            code.1133 = code;
            code.1657 = code.1133;
            code.1658 = code.1657 + 1;
            code = code.1658;
            D.26492 = imb.b[3];
            *code.1657 = D.26492;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26478>:
      <D.23186>:
      <D.26424>:
      if (resume_unwind != 0) goto <D.26493>; else goto <D.26494>;
      <D.26493>:
      if (0 != 0) goto <D.26495>; else goto <D.26496>;
      <D.26495>:
      code.1133 = code;
      code.1659 = code.1133;
      code.1660 = code.1659 + 1;
      code = code.1660;
      *code.1659 = 102;
      <D.26496>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26499>; else goto <D.26500>;
        <D.26499>:
        code.1133 = code;
        code.1661 = code.1133;
        code.1662 = code.1661 + 1;
        code = code.1662;
        D.26503 = _amd64_rex_bits | 64;
        *code.1661 = D.26503;
        <D.26500>:
      }
      if (0 != 0) goto <D.26504>; else goto <D.26505>;
      <D.26504>:
      code.1133 = code;
      code.1663 = code.1133;
      code.1664 = code.1663 + 1;
      code = code.1664;
      *code.1663 = 198;
      if (1 != 0) goto <D.26508>; else goto <D.26509>;
      <D.26508>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26511>; else goto <D.26512>;
      <D.26511>:
      code.1133 = code;
      code.1665 = code.1133;
      code.1666 = code.1665 + 1;
      code = code.1666;
      *code.1665 = 4;
      code.1133 = code;
      code.1667 = code.1133;
      code.1668 = code.1667 + 1;
      code = code.1668;
      *code.1667 = 36;
      goto <D.26517>;
      <D.26512>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26520>; else goto <D.26521>;
      <D.26520>:
      code.1133 = code;
      code.1669 = code.1133;
      code.1670 = code.1669 + 1;
      code = code.1670;
      *code.1669 = 68;
      code.1133 = code;
      code.1671 = code.1133;
      code.1672 = code.1671 + 1;
      code = code.1672;
      *code.1671 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26527>;
      <D.26521>:
      code.1133 = code;
      code.1673 = code.1133;
      code.1674 = code.1673 + 1;
      code = code.1674;
      *code.1673 = 132;
      code.1133 = code;
      code.1675 = code.1133;
      code.1676 = code.1675 + 1;
      code = code.1676;
      *code.1675 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1677 = code.1133;
            code.1678 = code.1677 + 1;
            code = code.1678;
            D.26534 = imb.b[0];
            *code.1677 = D.26534;
            code.1133 = code;
            code.1679 = code.1133;
            code.1680 = code.1679 + 1;
            code = code.1680;
            D.26537 = imb.b[1];
            *code.1679 = D.26537;
            code.1133 = code;
            code.1681 = code.1133;
            code.1682 = code.1681 + 1;
            code = code.1682;
            D.26540 = imb.b[2];
            *code.1681 = D.26540;
            code.1133 = code;
            code.1683 = code.1133;
            code.1684 = code.1683 + 1;
            code = code.1684;
            D.26543 = imb.b[3];
            *code.1683 = D.26543;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26527>:
      <D.26517>:
      goto <D.23190>;
      <D.26509>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26544>; else goto <D.26545>;
      <D.26544>:
      code.1133 = code;
      code.1685 = code.1133;
      code.1686 = code.1685 + 1;
      code = code.1686;
      *code.1685 = 4;
      goto <D.23190>;
      <D.26545>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26548>; else goto <D.26549>;
      <D.26548>:
      code.1133 = code;
      code.1687 = code.1133;
      code.1688 = code.1687 + 1;
      code = code.1688;
      *code.1687 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26552>;
      <D.26549>:
      code.1133 = code;
      code.1689 = code.1133;
      code.1690 = code.1689 + 1;
      code = code.1690;
      *code.1689 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1691 = code.1133;
            code.1692 = code.1691 + 1;
            code = code.1692;
            D.26557 = imb.b[0];
            *code.1691 = D.26557;
            code.1133 = code;
            code.1693 = code.1133;
            code.1694 = code.1693 + 1;
            code = code.1694;
            D.26560 = imb.b[1];
            *code.1693 = D.26560;
            code.1133 = code;
            code.1695 = code.1133;
            code.1696 = code.1695 + 1;
            code = code.1696;
            D.26563 = imb.b[2];
            *code.1695 = D.26563;
            code.1133 = code;
            code.1697 = code.1133;
            code.1698 = code.1697 + 1;
            code = code.1698;
            D.26566 = imb.b[3];
            *code.1697 = D.26566;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26552>:
      <D.23190>:
      code.1133 = code;
      *code.1133 = 0;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26567>;
      <D.26505>:
      if (0 != 0) goto <D.26568>; else goto <D.26569>;
      <D.26568>:
      code.1133 = code;
      code.1699 = code.1133;
      code.1700 = code.1699 + 1;
      code = code.1700;
      *code.1699 = 199;
      if (1 != 0) goto <D.26572>; else goto <D.26573>;
      <D.26572>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26574>; else goto <D.26575>;
      <D.26574>:
      code.1133 = code;
      code.1701 = code.1133;
      code.1702 = code.1701 + 1;
      code = code.1702;
      *code.1701 = 4;
      code.1133 = code;
      code.1703 = code.1133;
      code.1704 = code.1703 + 1;
      code = code.1704;
      *code.1703 = 36;
      goto <D.26580>;
      <D.26575>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26581>; else goto <D.26582>;
      <D.26581>:
      code.1133 = code;
      code.1705 = code.1133;
      code.1706 = code.1705 + 1;
      code = code.1706;
      *code.1705 = 68;
      code.1133 = code;
      code.1707 = code.1133;
      code.1708 = code.1707 + 1;
      code = code.1708;
      *code.1707 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26587>;
      <D.26582>:
      code.1133 = code;
      code.1709 = code.1133;
      code.1710 = code.1709 + 1;
      code = code.1710;
      *code.1709 = 132;
      code.1133 = code;
      code.1711 = code.1133;
      code.1712 = code.1711 + 1;
      code = code.1712;
      *code.1711 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1713 = code.1133;
            code.1714 = code.1713 + 1;
            code = code.1714;
            D.26594 = imb.b[0];
            *code.1713 = D.26594;
            code.1133 = code;
            code.1715 = code.1133;
            code.1716 = code.1715 + 1;
            code = code.1716;
            D.26597 = imb.b[1];
            *code.1715 = D.26597;
            code.1133 = code;
            code.1717 = code.1133;
            code.1718 = code.1717 + 1;
            code = code.1718;
            D.26600 = imb.b[2];
            *code.1717 = D.26600;
            code.1133 = code;
            code.1719 = code.1133;
            code.1720 = code.1719 + 1;
            code = code.1720;
            D.26603 = imb.b[3];
            *code.1719 = D.26603;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26587>:
      <D.26580>:
      goto <D.23193>;
      <D.26573>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26604>; else goto <D.26605>;
      <D.26604>:
      code.1133 = code;
      code.1721 = code.1133;
      code.1722 = code.1721 + 1;
      code = code.1722;
      *code.1721 = 4;
      goto <D.23193>;
      <D.26605>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26608>; else goto <D.26609>;
      <D.26608>:
      code.1133 = code;
      code.1723 = code.1133;
      code.1724 = code.1723 + 1;
      code = code.1724;
      *code.1723 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26612>;
      <D.26609>:
      code.1133 = code;
      code.1725 = code.1133;
      code.1726 = code.1725 + 1;
      code = code.1726;
      *code.1725 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1727 = code.1133;
            code.1728 = code.1727 + 1;
            code = code.1728;
            D.26617 = imb.b[0];
            *code.1727 = D.26617;
            code.1133 = code;
            code.1729 = code.1133;
            code.1730 = code.1729 + 1;
            code = code.1730;
            D.26620 = imb.b[1];
            *code.1729 = D.26620;
            code.1133 = code;
            code.1731 = code.1133;
            code.1732 = code.1731 + 1;
            code = code.1732;
            D.26623 = imb.b[2];
            *code.1731 = D.26623;
            code.1133 = code;
            code.1733 = code.1133;
            code.1734 = code.1733 + 1;
            code = code.1734;
            D.26626 = imb.b[3];
            *code.1733 = D.26626;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26612>:
      <D.23193>:
      code.1133 = code;
      MEM[(short int *)code.1133] = 0;
      code.1133 = code;
      code.1572 = code.1133 + 2;
      code = code.1572;
      goto <D.26627>;
      <D.26569>:
      code.1133 = code;
      code.1735 = code.1133;
      code.1736 = code.1735 + 1;
      code = code.1736;
      *code.1735 = 199;
      if (1 != 0) goto <D.26630>; else goto <D.26631>;
      <D.26630>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26632>; else goto <D.26633>;
      <D.26632>:
      code.1133 = code;
      code.1737 = code.1133;
      code.1738 = code.1737 + 1;
      code = code.1738;
      *code.1737 = 4;
      code.1133 = code;
      code.1739 = code.1133;
      code.1740 = code.1739 + 1;
      code = code.1740;
      *code.1739 = 36;
      goto <D.26638>;
      <D.26633>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26639>; else goto <D.26640>;
      <D.26639>:
      code.1133 = code;
      code.1741 = code.1133;
      code.1742 = code.1741 + 1;
      code = code.1742;
      *code.1741 = 68;
      code.1133 = code;
      code.1743 = code.1133;
      code.1744 = code.1743 + 1;
      code = code.1744;
      *code.1743 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26645>;
      <D.26640>:
      code.1133 = code;
      code.1745 = code.1133;
      code.1746 = code.1745 + 1;
      code = code.1746;
      *code.1745 = 132;
      code.1133 = code;
      code.1747 = code.1133;
      code.1748 = code.1747 + 1;
      code = code.1748;
      *code.1747 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1749 = code.1133;
            code.1750 = code.1749 + 1;
            code = code.1750;
            D.26652 = imb.b[0];
            *code.1749 = D.26652;
            code.1133 = code;
            code.1751 = code.1133;
            code.1752 = code.1751 + 1;
            code = code.1752;
            D.26655 = imb.b[1];
            *code.1751 = D.26655;
            code.1133 = code;
            code.1753 = code.1133;
            code.1754 = code.1753 + 1;
            code = code.1754;
            D.26658 = imb.b[2];
            *code.1753 = D.26658;
            code.1133 = code;
            code.1755 = code.1133;
            code.1756 = code.1755 + 1;
            code = code.1756;
            D.26661 = imb.b[3];
            *code.1755 = D.26661;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26645>:
      <D.26638>:
      goto <D.23196>;
      <D.26631>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26662>; else goto <D.26663>;
      <D.26662>:
      code.1133 = code;
      code.1757 = code.1133;
      code.1758 = code.1757 + 1;
      code = code.1758;
      *code.1757 = 4;
      goto <D.23196>;
      <D.26663>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26666>; else goto <D.26667>;
      <D.26666>:
      code.1133 = code;
      code.1759 = code.1133;
      code.1760 = code.1759 + 1;
      code = code.1760;
      *code.1759 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26670>;
      <D.26667>:
      code.1133 = code;
      code.1761 = code.1133;
      code.1762 = code.1761 + 1;
      code = code.1762;
      *code.1761 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1763 = code.1133;
            code.1764 = code.1763 + 1;
            code = code.1764;
            D.26675 = imb.b[0];
            *code.1763 = D.26675;
            code.1133 = code;
            code.1765 = code.1133;
            code.1766 = code.1765 + 1;
            code = code.1766;
            D.26678 = imb.b[1];
            *code.1765 = D.26678;
            code.1133 = code;
            code.1767 = code.1133;
            code.1768 = code.1767 + 1;
            code = code.1768;
            D.26681 = imb.b[2];
            *code.1767 = D.26681;
            code.1133 = code;
            code.1769 = code.1133;
            code.1770 = code.1769 + 1;
            code = code.1770;
            D.26684 = imb.b[3];
            *code.1769 = D.26684;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26670>:
      <D.23196>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1133 = code;
            code.1771 = code.1133;
            code.1772 = code.1771 + 1;
            code = code.1772;
            D.26687 = imb.b[0];
            *code.1771 = D.26687;
            code.1133 = code;
            code.1773 = code.1133;
            code.1774 = code.1773 + 1;
            code = code.1774;
            D.26690 = imb.b[1];
            *code.1773 = D.26690;
            code.1133 = code;
            code.1775 = code.1133;
            code.1776 = code.1775 + 1;
            code = code.1776;
            D.26693 = imb.b[2];
            *code.1775 = D.26693;
            code.1133 = code;
            code.1777 = code.1133;
            code.1778 = code.1777 + 1;
            code = code.1778;
            D.26696 = imb.b[3];
            *code.1777 = D.26696;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26627>:
      <D.26567>:
      goto <D.26697>;
      <D.26494>:
      if (corlib != 0) goto <D.26698>; else goto <D.26699>;
      <D.26698>:
      if (0 != 0) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      code.1133 = code;
      code.1779 = code.1133;
      code.1780 = code.1779 + 1;
      code = code.1780;
      *code.1779 = 102;
      <D.26701>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26704>; else goto <D.26705>;
        <D.26704>:
        code.1133 = code;
        code.1781 = code.1133;
        code.1782 = code.1781 + 1;
        code = code.1782;
        D.26708 = _amd64_rex_bits | 64;
        *code.1781 = D.26708;
        <D.26705>:
      }
      switch (8) <default: <D.23205>, case 1: <D.23200>, case 2: <D.23202>, case 4: <D.23203>, case 8: <D.23204>>
      <D.23200>:
      code.1133 = code;
      code.1783 = code.1133;
      code.1784 = code.1783 + 1;
      code = code.1784;
      *code.1783 = 136;
      goto <D.23201>;
      <D.23202>:
      <D.23203>:
      <D.23204>:
      code.1133 = code;
      code.1785 = code.1133;
      code.1786 = code.1785 + 1;
      code = code.1786;
      *code.1785 = 137;
      goto <D.23201>;
      <D.23205>:
      __assert_fail ("0", "exceptions-amd64.c", 497, &__PRETTY_FUNCTION__);
      <D.23201>:
      if (1 != 0) goto <D.26713>; else goto <D.26714>;
      <D.26713>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26715>; else goto <D.26716>;
      <D.26715>:
      code.1133 = code;
      code.1787 = code.1133;
      code.1788 = code.1787 + 1;
      code = code.1788;
      *code.1787 = 52;
      code.1133 = code;
      code.1789 = code.1133;
      code.1790 = code.1789 + 1;
      code = code.1790;
      *code.1789 = 36;
      goto <D.26721>;
      <D.26716>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26722>; else goto <D.26723>;
      <D.26722>:
      code.1133 = code;
      code.1791 = code.1133;
      code.1792 = code.1791 + 1;
      code = code.1792;
      *code.1791 = 116;
      code.1133 = code;
      code.1793 = code.1133;
      code.1794 = code.1793 + 1;
      code = code.1794;
      *code.1793 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26728>;
      <D.26723>:
      code.1133 = code;
      code.1795 = code.1133;
      code.1796 = code.1795 + 1;
      code = code.1796;
      *code.1795 = 180;
      code.1133 = code;
      code.1797 = code.1133;
      code.1798 = code.1797 + 1;
      code = code.1798;
      *code.1797 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1799 = code.1133;
            code.1800 = code.1799 + 1;
            code = code.1800;
            D.26735 = imb.b[0];
            *code.1799 = D.26735;
            code.1133 = code;
            code.1801 = code.1133;
            code.1802 = code.1801 + 1;
            code = code.1802;
            D.26738 = imb.b[1];
            *code.1801 = D.26738;
            code.1133 = code;
            code.1803 = code.1133;
            code.1804 = code.1803 + 1;
            code = code.1804;
            D.26741 = imb.b[2];
            *code.1803 = D.26741;
            code.1133 = code;
            code.1805 = code.1133;
            code.1806 = code.1805 + 1;
            code = code.1806;
            D.26744 = imb.b[3];
            *code.1805 = D.26744;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26728>:
      <D.26721>:
      goto <D.23207>;
      <D.26714>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26745>; else goto <D.26746>;
      <D.26745>:
      code.1133 = code;
      code.1807 = code.1133;
      code.1808 = code.1807 + 1;
      code = code.1808;
      *code.1807 = 52;
      goto <D.23207>;
      <D.26746>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26749>; else goto <D.26750>;
      <D.26749>:
      code.1133 = code;
      code.1809 = code.1133;
      code.1810 = code.1809 + 1;
      code = code.1810;
      *code.1809 = 116;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26753>;
      <D.26750>:
      code.1133 = code;
      code.1811 = code.1133;
      code.1812 = code.1811 + 1;
      code = code.1812;
      *code.1811 = 180;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1813 = code.1133;
            code.1814 = code.1813 + 1;
            code = code.1814;
            D.26758 = imb.b[0];
            *code.1813 = D.26758;
            code.1133 = code;
            code.1815 = code.1133;
            code.1816 = code.1815 + 1;
            code = code.1816;
            D.26761 = imb.b[1];
            *code.1815 = D.26761;
            code.1133 = code;
            code.1817 = code.1133;
            code.1818 = code.1817 + 1;
            code = code.1818;
            D.26764 = imb.b[2];
            *code.1817 = D.26764;
            code.1133 = code;
            code.1819 = code.1133;
            code.1820 = code.1819 + 1;
            code = code.1820;
            D.26767 = imb.b[3];
            *code.1819 = D.26767;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26753>:
      <D.23207>:
      if (llvm_abs != 0) goto <D.26768>; else goto <D.26769>;
      <D.26768>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26770>; else goto <D.26771>;
        <D.26770>:
        code.1133 = code;
        code.1821 = code.1133;
        code.1822 = code.1821 + 1;
        code = code.1822;
        D.26774 = _amd64_rex_bits | 64;
        *code.1821 = D.26774;
        <D.26771>:
      }
      code.1133 = code;
      code.1823 = code.1133;
      code.1824 = code.1823 + 1;
      code = code.1824;
      *code.1823 = 247;
      if (1 != 0) goto <D.26777>; else goto <D.26778>;
      <D.26777>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26779>; else goto <D.26780>;
      <D.26779>:
      code.1133 = code;
      code.1825 = code.1133;
      code.1826 = code.1825 + 1;
      code = code.1826;
      *code.1825 = 28;
      code.1133 = code;
      code.1827 = code.1133;
      code.1828 = code.1827 + 1;
      code = code.1828;
      *code.1827 = 36;
      goto <D.26785>;
      <D.26780>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26786>; else goto <D.26787>;
      <D.26786>:
      code.1133 = code;
      code.1829 = code.1133;
      code.1830 = code.1829 + 1;
      code = code.1830;
      *code.1829 = 92;
      code.1133 = code;
      code.1831 = code.1133;
      code.1832 = code.1831 + 1;
      code = code.1832;
      *code.1831 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26792>;
      <D.26787>:
      code.1133 = code;
      code.1833 = code.1133;
      code.1834 = code.1833 + 1;
      code = code.1834;
      *code.1833 = 156;
      code.1133 = code;
      code.1835 = code.1133;
      code.1836 = code.1835 + 1;
      code = code.1836;
      *code.1835 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1837 = code.1133;
            code.1838 = code.1837 + 1;
            code = code.1838;
            D.26799 = imb.b[0];
            *code.1837 = D.26799;
            code.1133 = code;
            code.1839 = code.1133;
            code.1840 = code.1839 + 1;
            code = code.1840;
            D.26802 = imb.b[1];
            *code.1839 = D.26802;
            code.1133 = code;
            code.1841 = code.1133;
            code.1842 = code.1841 + 1;
            code = code.1842;
            D.26805 = imb.b[2];
            *code.1841 = D.26805;
            code.1133 = code;
            code.1843 = code.1133;
            code.1844 = code.1843 + 1;
            code = code.1844;
            D.26808 = imb.b[3];
            *code.1843 = D.26808;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26792>:
      <D.26785>:
      goto <D.23211>;
      <D.26778>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26809>; else goto <D.26810>;
      <D.26809>:
      code.1133 = code;
      code.1845 = code.1133;
      code.1846 = code.1845 + 1;
      code = code.1846;
      *code.1845 = 28;
      goto <D.23211>;
      <D.26810>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26813>; else goto <D.26814>;
      <D.26813>:
      code.1133 = code;
      code.1847 = code.1133;
      code.1848 = code.1847 + 1;
      code = code.1848;
      *code.1847 = 92;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26817>;
      <D.26814>:
      code.1133 = code;
      code.1849 = code.1133;
      code.1850 = code.1849 + 1;
      code = code.1850;
      *code.1849 = 156;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1851 = code.1133;
            code.1852 = code.1851 + 1;
            code = code.1852;
            D.26822 = imb.b[0];
            *code.1851 = D.26822;
            code.1133 = code;
            code.1853 = code.1133;
            code.1854 = code.1853 + 1;
            code = code.1854;
            D.26825 = imb.b[1];
            *code.1853 = D.26825;
            code.1133 = code;
            code.1855 = code.1133;
            code.1856 = code.1855 + 1;
            code = code.1856;
            D.26828 = imb.b[2];
            *code.1855 = D.26828;
            code.1133 = code;
            code.1857 = code.1133;
            code.1858 = code.1857 + 1;
            code = code.1858;
            D.26831 = imb.b[3];
            *code.1857 = D.26831;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26817>:
      <D.23211>:
      <D.26769>:
      goto <D.26832>;
      <D.26699>:
      if (0 != 0) goto <D.26833>; else goto <D.26834>;
      <D.26833>:
      code.1133 = code;
      code.1859 = code.1133;
      code.1860 = code.1859 + 1;
      code = code.1860;
      *code.1859 = 102;
      <D.26834>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.26837>; else goto <D.26838>;
        <D.26837>:
        code.1133 = code;
        code.1861 = code.1133;
        code.1862 = code.1861 + 1;
        code = code.1862;
        D.26841 = _amd64_rex_bits | 64;
        *code.1861 = D.26841;
        <D.26838>:
      }
      if (0 != 0) goto <D.26842>; else goto <D.26843>;
      <D.26842>:
      code.1133 = code;
      code.1863 = code.1133;
      code.1864 = code.1863 + 1;
      code = code.1864;
      *code.1863 = 198;
      if (1 != 0) goto <D.26846>; else goto <D.26847>;
      <D.26846>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26848>; else goto <D.26849>;
      <D.26848>:
      code.1133 = code;
      code.1865 = code.1133;
      code.1866 = code.1865 + 1;
      code = code.1866;
      *code.1865 = 4;
      code.1133 = code;
      code.1867 = code.1133;
      code.1868 = code.1867 + 1;
      code = code.1868;
      *code.1867 = 36;
      goto <D.26854>;
      <D.26849>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26855>; else goto <D.26856>;
      <D.26855>:
      code.1133 = code;
      code.1869 = code.1133;
      code.1870 = code.1869 + 1;
      code = code.1870;
      *code.1869 = 68;
      code.1133 = code;
      code.1871 = code.1133;
      code.1872 = code.1871 + 1;
      code = code.1872;
      *code.1871 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26861>;
      <D.26856>:
      code.1133 = code;
      code.1873 = code.1133;
      code.1874 = code.1873 + 1;
      code = code.1874;
      *code.1873 = 132;
      code.1133 = code;
      code.1875 = code.1133;
      code.1876 = code.1875 + 1;
      code = code.1876;
      *code.1875 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1877 = code.1133;
            code.1878 = code.1877 + 1;
            code = code.1878;
            D.26868 = imb.b[0];
            *code.1877 = D.26868;
            code.1133 = code;
            code.1879 = code.1133;
            code.1880 = code.1879 + 1;
            code = code.1880;
            D.26871 = imb.b[1];
            *code.1879 = D.26871;
            code.1133 = code;
            code.1881 = code.1133;
            code.1882 = code.1881 + 1;
            code = code.1882;
            D.26874 = imb.b[2];
            *code.1881 = D.26874;
            code.1133 = code;
            code.1883 = code.1133;
            code.1884 = code.1883 + 1;
            code = code.1884;
            D.26877 = imb.b[3];
            *code.1883 = D.26877;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26861>:
      <D.26854>:
      goto <D.23215>;
      <D.26847>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26878>; else goto <D.26879>;
      <D.26878>:
      code.1133 = code;
      code.1885 = code.1133;
      code.1886 = code.1885 + 1;
      code = code.1886;
      *code.1885 = 4;
      goto <D.23215>;
      <D.26879>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26882>; else goto <D.26883>;
      <D.26882>:
      code.1133 = code;
      code.1887 = code.1133;
      code.1888 = code.1887 + 1;
      code = code.1888;
      *code.1887 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26886>;
      <D.26883>:
      code.1133 = code;
      code.1889 = code.1133;
      code.1890 = code.1889 + 1;
      code = code.1890;
      *code.1889 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1891 = code.1133;
            code.1892 = code.1891 + 1;
            code = code.1892;
            D.26891 = imb.b[0];
            *code.1891 = D.26891;
            code.1133 = code;
            code.1893 = code.1133;
            code.1894 = code.1893 + 1;
            code = code.1894;
            D.26894 = imb.b[1];
            *code.1893 = D.26894;
            code.1133 = code;
            code.1895 = code.1133;
            code.1896 = code.1895 + 1;
            code = code.1896;
            D.26897 = imb.b[2];
            *code.1895 = D.26897;
            code.1133 = code;
            code.1897 = code.1133;
            code.1898 = code.1897 + 1;
            code = code.1898;
            D.26900 = imb.b[3];
            *code.1897 = D.26900;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26886>:
      <D.23215>:
      code.1133 = code;
      D.26901 = (unsigned char) rethrow;
      *code.1133 = D.26901;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26902>;
      <D.26843>:
      if (0 != 0) goto <D.26903>; else goto <D.26904>;
      <D.26903>:
      code.1133 = code;
      code.1899 = code.1133;
      code.1900 = code.1899 + 1;
      code = code.1900;
      *code.1899 = 199;
      if (1 != 0) goto <D.26907>; else goto <D.26908>;
      <D.26907>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26909>; else goto <D.26910>;
      <D.26909>:
      code.1133 = code;
      code.1901 = code.1133;
      code.1902 = code.1901 + 1;
      code = code.1902;
      *code.1901 = 4;
      code.1133 = code;
      code.1903 = code.1133;
      code.1904 = code.1903 + 1;
      code = code.1904;
      *code.1903 = 36;
      goto <D.26915>;
      <D.26910>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26916>; else goto <D.26917>;
      <D.26916>:
      code.1133 = code;
      code.1905 = code.1133;
      code.1906 = code.1905 + 1;
      code = code.1906;
      *code.1905 = 68;
      code.1133 = code;
      code.1907 = code.1133;
      code.1908 = code.1907 + 1;
      code = code.1908;
      *code.1907 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26922>;
      <D.26917>:
      code.1133 = code;
      code.1909 = code.1133;
      code.1910 = code.1909 + 1;
      code = code.1910;
      *code.1909 = 132;
      code.1133 = code;
      code.1911 = code.1133;
      code.1912 = code.1911 + 1;
      code = code.1912;
      *code.1911 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1913 = code.1133;
            code.1914 = code.1913 + 1;
            code = code.1914;
            D.26929 = imb.b[0];
            *code.1913 = D.26929;
            code.1133 = code;
            code.1915 = code.1133;
            code.1916 = code.1915 + 1;
            code = code.1916;
            D.26932 = imb.b[1];
            *code.1915 = D.26932;
            code.1133 = code;
            code.1917 = code.1133;
            code.1918 = code.1917 + 1;
            code = code.1918;
            D.26935 = imb.b[2];
            *code.1917 = D.26935;
            code.1133 = code;
            code.1919 = code.1133;
            code.1920 = code.1919 + 1;
            code = code.1920;
            D.26938 = imb.b[3];
            *code.1919 = D.26938;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26922>:
      <D.26915>:
      goto <D.23218>;
      <D.26908>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26939>; else goto <D.26940>;
      <D.26939>:
      code.1133 = code;
      code.1921 = code.1133;
      code.1922 = code.1921 + 1;
      code = code.1922;
      *code.1921 = 4;
      goto <D.23218>;
      <D.26940>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26943>; else goto <D.26944>;
      <D.26943>:
      code.1133 = code;
      code.1923 = code.1133;
      code.1924 = code.1923 + 1;
      code = code.1924;
      *code.1923 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26947>;
      <D.26944>:
      code.1133 = code;
      code.1925 = code.1133;
      code.1926 = code.1925 + 1;
      code = code.1926;
      *code.1925 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1927 = code.1133;
            code.1928 = code.1927 + 1;
            code = code.1928;
            D.26952 = imb.b[0];
            *code.1927 = D.26952;
            code.1133 = code;
            code.1929 = code.1133;
            code.1930 = code.1929 + 1;
            code = code.1930;
            D.26955 = imb.b[1];
            *code.1929 = D.26955;
            code.1133 = code;
            code.1931 = code.1133;
            code.1932 = code.1931 + 1;
            code = code.1932;
            D.26958 = imb.b[2];
            *code.1931 = D.26958;
            code.1133 = code;
            code.1933 = code.1133;
            code.1934 = code.1933 + 1;
            code = code.1934;
            D.26961 = imb.b[3];
            *code.1933 = D.26961;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26947>:
      <D.23218>:
      code.1133 = code;
      D.26962 = (short int) rethrow;
      MEM[(short int *)code.1133] = D.26962;
      code.1133 = code;
      code.1572 = code.1133 + 2;
      code = code.1572;
      goto <D.26963>;
      <D.26904>:
      code.1133 = code;
      code.1935 = code.1133;
      code.1936 = code.1935 + 1;
      code = code.1936;
      *code.1935 = 199;
      if (1 != 0) goto <D.26966>; else goto <D.26967>;
      <D.26966>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26968>; else goto <D.26969>;
      <D.26968>:
      code.1133 = code;
      code.1937 = code.1133;
      code.1938 = code.1937 + 1;
      code = code.1938;
      *code.1937 = 4;
      code.1133 = code;
      code.1939 = code.1133;
      code.1940 = code.1939 + 1;
      code = code.1940;
      *code.1939 = 36;
      goto <D.26974>;
      <D.26969>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.26975>; else goto <D.26976>;
      <D.26975>:
      code.1133 = code;
      code.1941 = code.1133;
      code.1942 = code.1941 + 1;
      code = code.1942;
      *code.1941 = 68;
      code.1133 = code;
      code.1943 = code.1133;
      code.1944 = code.1943 + 1;
      code = code.1944;
      *code.1943 = 36;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.26981>;
      <D.26976>:
      code.1133 = code;
      code.1945 = code.1133;
      code.1946 = code.1945 + 1;
      code = code.1946;
      *code.1945 = 132;
      code.1133 = code;
      code.1947 = code.1133;
      code.1948 = code.1947 + 1;
      code = code.1948;
      *code.1947 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1949 = code.1133;
            code.1950 = code.1949 + 1;
            code = code.1950;
            D.26988 = imb.b[0];
            *code.1949 = D.26988;
            code.1133 = code;
            code.1951 = code.1133;
            code.1952 = code.1951 + 1;
            code = code.1952;
            D.26991 = imb.b[1];
            *code.1951 = D.26991;
            code.1133 = code;
            code.1953 = code.1133;
            code.1954 = code.1953 + 1;
            code = code.1954;
            D.26994 = imb.b[2];
            *code.1953 = D.26994;
            code.1133 = code;
            code.1955 = code.1133;
            code.1956 = code.1955 + 1;
            code = code.1956;
            D.26997 = imb.b[3];
            *code.1955 = D.26997;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26981>:
      <D.26974>:
      goto <D.23221>;
      <D.26967>:
      D.26510 = arg_offsets[3];
      if (D.26510 == 0) goto <D.26998>; else goto <D.26999>;
      <D.26998>:
      code.1133 = code;
      code.1957 = code.1133;
      code.1958 = code.1957 + 1;
      code = code.1958;
      *code.1957 = 4;
      goto <D.23221>;
      <D.26999>:
      D.26510 = arg_offsets[3];
      D.26518 = (unsigned int) D.26510;
      D.26519 = D.26518 + 128;
      if (D.26519 <= 255) goto <D.27002>; else goto <D.27003>;
      <D.27002>:
      code.1133 = code;
      code.1959 = code.1133;
      code.1960 = code.1959 + 1;
      code = code.1960;
      *code.1959 = 68;
      code.1133 = code;
      D.26510 = arg_offsets[3];
      D.26526 = (unsigned char) D.26510;
      *code.1133 = D.26526;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.27006>;
      <D.27003>:
      code.1133 = code;
      code.1961 = code.1133;
      code.1962 = code.1961 + 1;
      code = code.1962;
      *code.1961 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            D.26510 = arg_offsets[3];
            imb.val = D.26510;
            code.1133 = code;
            code.1963 = code.1133;
            code.1964 = code.1963 + 1;
            code = code.1964;
            D.27011 = imb.b[0];
            *code.1963 = D.27011;
            code.1133 = code;
            code.1965 = code.1133;
            code.1966 = code.1965 + 1;
            code = code.1966;
            D.27014 = imb.b[1];
            *code.1965 = D.27014;
            code.1133 = code;
            code.1967 = code.1133;
            code.1968 = code.1967 + 1;
            code = code.1968;
            D.27017 = imb.b[2];
            *code.1967 = D.27017;
            code.1133 = code;
            code.1969 = code.1133;
            code.1970 = code.1969 + 1;
            code = code.1970;
            D.27020 = imb.b[3];
            *code.1969 = D.27020;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27006>:
      <D.23221>:
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = rethrow;
            code.1133 = code;
            code.1971 = code.1133;
            code.1972 = code.1971 + 1;
            code = code.1972;
            D.27023 = imb.b[0];
            *code.1971 = D.27023;
            code.1133 = code;
            code.1973 = code.1133;
            code.1974 = code.1973 + 1;
            code = code.1974;
            D.27026 = imb.b[1];
            *code.1973 = D.27026;
            code.1133 = code;
            code.1975 = code.1133;
            code.1976 = code.1975 + 1;
            code = code.1976;
            D.27029 = imb.b[2];
            *code.1975 = D.27029;
            code.1133 = code;
            code.1977 = code.1133;
            code.1978 = code.1977 + 1;
            code = code.1978;
            D.27032 = imb.b[3];
            *code.1977 = D.27032;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.26963>:
      <D.26902>:
      <D.26832>:
      <D.26697>:
      if (aot != 0) goto <D.27033>; else goto <D.27034>;
      <D.27033>:
      if (corlib != 0) goto <D.27036>; else goto <D.27037>;
      <D.27036>:
      iftmp.1979 = "mono_amd64_throw_corlib_exception";
      goto <D.27038>;
      <D.27037>:
      iftmp.1979 = "mono_amd64_throw_exception";
      <D.27038>:
      code.1133 = code;
      code.1169 = (long int) code.1133;
      start.1134 = start;
      start.1170 = (long int) start.1134;
      D.25629 = code.1169 - start.1170;
      D.25630 = (int) D.25629;
      ji = mono_patch_info_list_prepend (ji, D.25630, 32, iftmp.1979);
      if (0 != 0) goto <D.27039>; else goto <D.27040>;
      <D.27039>:
      code.1133 = code;
      code.1980 = code.1133;
      code.1981 = code.1980 + 1;
      code = code.1981;
      *code.1980 = 102;
      <D.27040>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.27043>; else goto <D.27044>;
        <D.27043>:
        code.1133 = code;
        code.1982 = code.1133;
        code.1983 = code.1982 + 1;
        code = code.1983;
        D.27047 = _amd64_rex_bits | 64;
        *code.1982 = D.27047;
        <D.27044>:
      }
      switch (8) <default: <D.23230>, case 1: <D.23225>, case 2: <D.23227>, case 4: <D.23228>, case 8: <D.23229>>
      <D.23225>:
      code.1133 = code;
      code.1984 = code.1133;
      code.1985 = code.1984 + 1;
      code = code.1985;
      *code.1984 = 138;
      goto <D.23226>;
      <D.23227>:
      <D.23228>:
      <D.23229>:
      code.1133 = code;
      code.1986 = code.1133;
      code.1987 = code.1986 + 1;
      code = code.1987;
      *code.1986 = 139;
      goto <D.23226>;
      <D.23230>:
      __assert_fail ("0", "exceptions-amd64.c", 511, &__PRETTY_FUNCTION__);
      <D.23226>:
      if (1 != 0) goto <D.27052>; else goto <D.27053>;
      <D.27052>:
      code.1133 = code;
      code.1988 = code.1133;
      code.1989 = code.1988 + 1;
      code = code.1989;
      *code.1988 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1133 = code;
            code.1990 = code.1133;
            code.1991 = code.1990 + 1;
            code = code.1991;
            D.27058 = imb.b[0];
            *code.1990 = D.27058;
            code.1133 = code;
            code.1992 = code.1133;
            code.1993 = code.1992 + 1;
            code = code.1993;
            D.27061 = imb.b[1];
            *code.1992 = D.27061;
            code.1133 = code;
            code.1994 = code.1133;
            code.1995 = code.1994 + 1;
            code = code.1995;
            D.27064 = imb.b[2];
            *code.1994 = D.27064;
            code.1133 = code;
            code.1996 = code.1133;
            code.1997 = code.1996 + 1;
            code = code.1997;
            D.27067 = imb.b[3];
            *code.1996 = D.27067;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27068>;
      <D.27053>:
      if (0 != 0) goto <D.27069>; else goto <D.27070>;
      <D.27069>:
      if (1 != 0) goto <D.27071>; else goto <D.27072>;
      <D.27071>:
      code.1133 = code;
      code.1998 = code.1133;
      code.1999 = code.1998 + 1;
      code = code.1999;
      *code.1998 = 28;
      code.1133 = code;
      code.2000 = code.1133;
      code.2001 = code.2000 + 1;
      code = code.2001;
      *code.2000 = 36;
      goto <D.27077>;
      <D.27072>:
      if (1 != 0) goto <D.27078>; else goto <D.27079>;
      <D.27078>:
      code.1133 = code;
      code.2002 = code.1133;
      code.2003 = code.2002 + 1;
      code = code.2003;
      *code.2002 = 92;
      code.1133 = code;
      code.2004 = code.1133;
      code.2005 = code.2004 + 1;
      code = code.2005;
      *code.2004 = 36;
      code.1133 = code;
      *code.1133 = 0;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.27084>;
      <D.27079>:
      code.1133 = code;
      code.2006 = code.1133;
      code.2007 = code.2006 + 1;
      code = code.2007;
      *code.2006 = 156;
      code.1133 = code;
      code.2008 = code.1133;
      code.2009 = code.2008 + 1;
      code = code.2009;
      *code.2008 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1133 = code;
            code.2010 = code.1133;
            code.2011 = code.2010 + 1;
            code = code.2011;
            D.27091 = imb.b[0];
            *code.2010 = D.27091;
            code.1133 = code;
            code.2012 = code.1133;
            code.2013 = code.2012 + 1;
            code = code.2013;
            D.27094 = imb.b[1];
            *code.2012 = D.27094;
            code.1133 = code;
            code.2014 = code.1133;
            code.2015 = code.2014 + 1;
            code = code.2015;
            D.27097 = imb.b[2];
            *code.2014 = D.27097;
            code.1133 = code;
            code.2016 = code.1133;
            code.2017 = code.2016 + 1;
            code = code.2017;
            D.27100 = imb.b[3];
            *code.2016 = D.27100;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27084>:
      <D.27077>:
      goto <D.23233>;
      <D.27070>:
      if (1 != 0) goto <D.27101>; else goto <D.27102>;
      <D.27101>:
      code.1133 = code;
      code.2018 = code.1133;
      code.2019 = code.2018 + 1;
      code = code.2019;
      *code.2018 = 24;
      goto <D.23233>;
      <D.27102>:
      if (1 != 0) goto <D.27105>; else goto <D.27106>;
      <D.27105>:
      code.1133 = code;
      code.2020 = code.1133;
      code.2021 = code.2020 + 1;
      code = code.2021;
      *code.2020 = 88;
      code.1133 = code;
      *code.1133 = 0;
      code.1133 = code;
      code.1142 = code.1133 + 1;
      code = code.1142;
      goto <D.27109>;
      <D.27106>:
      code.1133 = code;
      code.2022 = code.1133;
      code.2023 = code.2022 + 1;
      code = code.2023;
      *code.2022 = 152;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.1133 = code;
            code.2024 = code.1133;
            code.2025 = code.2024 + 1;
            code = code.2025;
            D.27114 = imb.b[0];
            *code.2024 = D.27114;
            code.1133 = code;
            code.2026 = code.1133;
            code.2027 = code.2026 + 1;
            code = code.2027;
            D.27117 = imb.b[1];
            *code.2026 = D.27117;
            code.1133 = code;
            code.2028 = code.1133;
            code.2029 = code.2028 + 1;
            code = code.2029;
            D.27120 = imb.b[2];
            *code.2028 = D.27120;
            code.1133 = code;
            code.2030 = code.1133;
            code.2031 = code.2030 + 1;
            code = code.2031;
            D.27123 = imb.b[3];
            *code.2030 = D.27123;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27109>:
      <D.23233>:
      <D.27068>:
      goto <D.27124>;
      <D.27034>:
      {
        int _amd64_width_temp;

        if (resume_unwind == 0) goto <D.27126>; else goto <D.27127>;
        <D.27126>:
        if (corlib != 0) goto <D.27129>; else goto <D.27130>;
        <D.27129>:
        iftmp.2033 = (long unsigned int) mono_amd64_throw_corlib_exception;
        goto <D.27131>;
        <D.27130>:
        iftmp.2033 = (long unsigned int) mono_amd64_throw_exception;
        <D.27131>:
        iftmp.2032 = iftmp.2033;
        goto <D.27132>;
        <D.27127>:
        iftmp.2032 = (long unsigned int) mono_amd64_resume_unwind;
        <D.27132>:
        if (resume_unwind == 0) goto <D.27134>; else goto <D.27135>;
        <D.27134>:
        if (corlib != 0) goto <D.27137>; else goto <D.27138>;
        <D.27137>:
        mono_amd64_throw_corlib_exception.2036 = (long int) mono_amd64_throw_corlib_exception;
        D.27140 = (int) mono_amd64_throw_corlib_exception.2036;
        iftmp.2035 = (long unsigned int) D.27140;
        goto <D.27141>;
        <D.27138>:
        mono_amd64_throw_exception.2037 = (long int) mono_amd64_throw_exception;
        D.27143 = (int) mono_amd64_throw_exception.2037;
        iftmp.2035 = (long unsigned int) D.27143;
        <D.27141>:
        iftmp.2034 = iftmp.2035;
        goto <D.27144>;
        <D.27135>:
        mono_amd64_resume_unwind.2038 = (long int) mono_amd64_resume_unwind;
        D.27146 = (int) mono_amd64_resume_unwind.2038;
        iftmp.2034 = (long unsigned int) D.27146;
        <D.27144>:
        D.27147 = iftmp.2032 == iftmp.2034;
        _amd64_width_temp = (int) D.27147;
        {
          unsigned char _amd64_rex_bits;

          if (_amd64_width_temp == 0) goto <D.27149>; else goto <D.27150>;
          <D.27149>:
          iftmp.2039 = 9;
          goto <D.27151>;
          <D.27150>:
          iftmp.2039 = 1;
          <D.27151>:
          _amd64_rex_bits = iftmp.2039;
          if (_amd64_rex_bits != 0) goto <D.27152>; else goto <D.27153>;
          <D.27152>:
          code.1133 = code;
          code.2040 = code.1133;
          code.2041 = code.2040 + 1;
          code = code.2041;
          D.27156 = _amd64_rex_bits | 64;
          *code.2040 = D.27156;
          <D.27153>:
        }
        code.1133 = code;
        code.2042 = code.1133;
        code.2043 = code.2042 + 1;
        code = code.2043;
        *code.2042 = 187;
        if (_amd64_width_temp == 0) goto <D.27159>; else goto <D.27160>;
        <D.27159>:
        {
          union amd64_imm_buf imb;

          try
            {
              if (resume_unwind == 0) goto <D.27162>; else goto <D.27163>;
              <D.27162>:
              if (corlib != 0) goto <D.27165>; else goto <D.27166>;
              <D.27165>:
              iftmp.2045 = (long unsigned int) mono_amd64_throw_corlib_exception;
              goto <D.27167>;
              <D.27166>:
              iftmp.2045 = (long unsigned int) mono_amd64_throw_exception;
              <D.27167>:
              iftmp.2044 = iftmp.2045;
              goto <D.27168>;
              <D.27163>:
              iftmp.2044 = (long unsigned int) mono_amd64_resume_unwind;
              <D.27168>:
              imb.val = iftmp.2044;
              code.1133 = code;
              code.2046 = code.1133;
              code.2047 = code.2046 + 1;
              code = code.2047;
              D.27171 = imb.b[0];
              *code.2046 = D.27171;
              code.1133 = code;
              code.2048 = code.1133;
              code.2049 = code.2048 + 1;
              code = code.2049;
              D.27174 = imb.b[1];
              *code.2048 = D.27174;
              code.1133 = code;
              code.2050 = code.1133;
              code.2051 = code.2050 + 1;
              code = code.2051;
              D.27177 = imb.b[2];
              *code.2050 = D.27177;
              code.1133 = code;
              code.2052 = code.1133;
              code.2053 = code.2052 + 1;
              code = code.2053;
              D.27180 = imb.b[3];
              *code.2052 = D.27180;
              code.1133 = code;
              code.2054 = code.1133;
              code.2055 = code.2054 + 1;
              code = code.2055;
              D.27183 = imb.b[4];
              *code.2054 = D.27183;
              code.1133 = code;
              code.2056 = code.1133;
              code.2057 = code.2056 + 1;
              code = code.2057;
              D.27186 = imb.b[5];
              *code.2056 = D.27186;
              code.1133 = code;
              code.2058 = code.1133;
              code.2059 = code.2058 + 1;
              code = code.2059;
              D.27189 = imb.b[6];
              *code.2058 = D.27189;
              code.1133 = code;
              code.2060 = code.1133;
              code.2061 = code.2060 + 1;
              code = code.2061;
              D.27192 = imb.b[7];
              *code.2060 = D.27192;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27193>;
        <D.27160>:
        {
          union x86_imm_buf imb;

          try
            {
              if (resume_unwind == 0) goto <D.27195>; else goto <D.27196>;
              <D.27195>:
              if (corlib != 0) goto <D.27198>; else goto <D.27199>;
              <D.27198>:
              mono_amd64_throw_corlib_exception.2036 = (long int) mono_amd64_throw_corlib_exception;
              iftmp.2063 = (int) mono_amd64_throw_corlib_exception.2036;
              goto <D.27200>;
              <D.27199>:
              mono_amd64_throw_exception.2037 = (long int) mono_amd64_throw_exception;
              iftmp.2063 = (int) mono_amd64_throw_exception.2037;
              <D.27200>:
              iftmp.2062 = iftmp.2063;
              goto <D.27201>;
              <D.27196>:
              mono_amd64_resume_unwind.2038 = (long int) mono_amd64_resume_unwind;
              iftmp.2062 = (int) mono_amd64_resume_unwind.2038;
              <D.27201>:
              imb.val = iftmp.2062;
              code.1133 = code;
              code.2064 = code.1133;
              code.2065 = code.2064 + 1;
              code = code.2065;
              D.27204 = imb.b[0];
              *code.2064 = D.27204;
              code.1133 = code;
              code.2066 = code.1133;
              code.2067 = code.2066 + 1;
              code = code.2067;
              D.27207 = imb.b[1];
              *code.2066 = D.27207;
              code.1133 = code;
              code.2068 = code.1133;
              code.2069 = code.2068 + 1;
              code = code.2069;
              D.27210 = imb.b[2];
              *code.2068 = D.27210;
              code.1133 = code;
              code.2070 = code.1133;
              code.2071 = code.2070 + 1;
              code = code.2071;
              D.27213 = imb.b[3];
              *code.2070 = D.27213;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.27193>:
      }
      <D.27124>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.27214>; else goto <D.27215>;
        <D.27214>:
        code.1133 = code;
        code.2072 = code.1133;
        code.2073 = code.2072 + 1;
        code = code.2073;
        D.27218 = _amd64_rex_bits | 64;
        *code.2072 = D.27218;
        <D.27215>:
      }
      code.1133 = code;
      code.2074 = code.1133;
      code.2075 = code.2074 + 1;
      code = code.2075;
      *code.2074 = 255;
      code.1133 = code;
      code.2076 = code.1133;
      code.2077 = code.2076 + 1;
      code = code.2077;
      *code.2076 = 211;
      code.1133 = code;
      code.2078 = code.1133;
      code.2079 = code.2078 + 1;
      code = code.2079;
      *code.2078 = 204;
      code.1133 = code;
      code.1169 = (long int) code.1133;
      start.1134 = start;
      start.1170 = (long int) start.1134;
      D.25629 = code.1169 - start.1170;
      D.27225 = (int) D.25629;
      start.1134 = start;
      mono_arch_flush_icache (start.1134, D.27225);
      code.1133 = code;
      code.1169 = (long int) code.1133;
      start.1134 = start;
      start.1170 = (long int) start.1134;
      D.25629 = code.1169 - start.1170;
      D.27226 = D.25629 > 255;
      D.27227 = (long int) D.27226;
      D.27228 = __builtin_expect (D.27227, 0);
      if (D.27228 != 0) goto <D.27229>; else goto <D.27230>;
      <D.27229>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 520, "(code - start) < kMaxCodeSize");
      <D.27230>:
      kMaxCodeSize.1131 = (int) kMaxCodeSize;
      nacl_global_codeman_validate (&start, kMaxCodeSize.1131, &code);
      if (info != 0B) goto <D.27231>; else goto <D.27232>;
      <D.27231>:
      code.1133 = code;
      code.1169 = (long int) code.1133;
      start.1134 = start;
      start.1170 = (long int) start.1134;
      D.25629 = code.1169 - start.1170;
      D.27233 = (unsigned int) D.25629;
      start.1134 = start;
      D.27234 = mono_tramp_info_create (tramp_name, start.1134, D.27233, ji, unwind_ops);
      *info = D.27234;
      <D.27232>:
      D.27235 = start;
      return D.27235;
    }
  finally
    {
      start = {CLOBBER};
      code = {CLOBBER};
      arg_offsets = {CLOBBER};
    }
}


mono_amd64_resume_unwind (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4, guint64 dummy5, guint64 dummy6, mgreg_t * regs, mgreg_t rip, guint32 dummy7, gint64 dummy8)
{
  long int D.27238;
  long int D.27239;
  long int D.27240;
  long int D.27241;
  long int D.27242;
  long int D.27243;
  long int D.27244;
  long int D.27245;
  long int D.27246;
  long int D.27247;
  long int D.27248;
  long int D.27249;
  struct MonoContext ctx;

  try
    {
      D.27238 = MEM[(mgreg_t *)regs + 32B];
      ctx.rsp = D.27238;
      ctx.rip = rip;
      D.27239 = MEM[(mgreg_t *)regs + 24B];
      ctx.rbx = D.27239;
      D.27240 = MEM[(mgreg_t *)regs + 40B];
      ctx.rbp = D.27240;
      D.27241 = MEM[(mgreg_t *)regs + 96B];
      ctx.r12 = D.27241;
      D.27242 = MEM[(mgreg_t *)regs + 104B];
      ctx.r13 = D.27242;
      D.27243 = MEM[(mgreg_t *)regs + 112B];
      ctx.r14 = D.27243;
      D.27244 = MEM[(mgreg_t *)regs + 120B];
      ctx.r15 = D.27244;
      D.27245 = MEM[(mgreg_t *)regs + 56B];
      ctx.rdi = D.27245;
      D.27246 = MEM[(mgreg_t *)regs + 48B];
      ctx.rsi = D.27246;
      D.27247 = *regs;
      ctx.rax = D.27247;
      D.27248 = MEM[(mgreg_t *)regs + 8B];
      ctx.rcx = D.27248;
      D.27249 = MEM[(mgreg_t *)regs + 16B];
      ctx.rdx = D.27249;
      mono_resume_unwind (&ctx);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_arch_get_rethrow_exception (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.27250;

  D.27250 = get_throw_trampoline (info, 1, 0, 0, 0, "rethrow_exception", aot);
  return D.27250;
}


mono_arch_get_throw_corlib_exception (struct MonoTrampInfo * * info, gboolean aot)
{
  void * D.27252;

  D.27252 = get_throw_trampoline (info, 0, 1, 0, 0, "throw_corlib_exception", aot);
  return D.27252;
}


mono_arch_find_jit_info (struct MonoDomain * domain, struct MonoJitTlsData * jit_tls, struct MonoJitInfo * ji, struct MonoContext * ctx, struct MonoContext * new_ctx, struct MonoLMF * * lmf, mgreg_t * * save_locations, struct StackFrameInfo * frame)
{
  long int D.27254;
  unsigned char D.27257;
  unsigned char D.27258;
  unsigned int D.27262;
  unsigned int unwind_info_len.2080;
  long int D.27264;
  long int D.27265;
  long int D.27266;
  long int D.27267;
  long int D.27268;
  long int D.27269;
  long int D.27270;
  long int D.27271;
  long int D.27272;
  long int D.27273;
  long int D.27274;
  long int D.27275;
  long int D.27276;
  void * D.27277;
  int D.27278;
  sizetype D.27279;
  guint8 * D.27280;
  long int D.27281;
  long int D.27282;
  long int D.27283;
  long int D.27284;
  long int D.27285;
  long int D.27286;
  long int D.27287;
  long int D.27288;
  long int D.27289;
  long int D.27290;
  long int D.27291;
  long int D.27292;
  long int D.27293;
  guint8 * cfa.2081;
  long int cfa.2082;
  long int D.27296;
  struct MonoLMF * D.27297;
  struct MonoLMF * D.27300;
  long int D.27303;
  void * D.27304;
  long unsigned int D.27305;
  void * D.27306;
  void * D.27309;
  long unsigned int D.27310;
  long unsigned int D.27311;
  struct MonoLMF * D.27312;
  gboolean D.27313;
  long unsigned int D.27316;
  int D.27319;
  _Bool D.27320;
  long int D.27321;
  long int D.27322;
  struct MonoContext * D.27325;
  long unsigned int D.27326;
  long unsigned int D.27332;
  guint64 * D.27333;
  char * rip.2083;
  long int rip.2084;
  long unsigned int D.27338;
  long int D.27339;
  long int D.27340;
  long unsigned int D.27341;
  guint64 * D.27344;
  guint64 * D.27345;
  long unsigned int D.27346;
  long int D.27347;
  guint64 * D.27348;
  long unsigned int D.27349;
  long int D.27350;
  guint64 * D.27351;
  long unsigned int D.27352;
  long int D.27353;
  guint64 * D.27354;
  long unsigned int D.27355;
  long int D.27356;
  guint64 * D.27357;
  long unsigned int D.27358;
  long int D.27359;
  void * ip;

  D.27254 = ctx->rip;
  ip = (void *) D.27254;
  memset (frame, 0, 88);
  frame->ji = ji;
  *new_ctx = *ctx;
  if (ji != 0B) goto <D.27255>; else goto <D.27256>;
  <D.27255>:
  {
    mgreg_t regs[17];
    guint8 * cfa;
    guint32 unwind_info_len;
    guint8 * unwind_info;

    try
      {
        frame->type = 0;
        D.27257 = BIT_FIELD_REF <*ji, 8, 272>;
        D.27258 = D.27257 & 16;
        if (D.27258 != 0) goto <D.27259>; else goto <D.27260>;
        <D.27259>:
        unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
        goto <D.27261>;
        <D.27260>:
        D.27262 = ji->used_regs;
        unwind_info = mono_get_cached_unwind_info (D.27262, &unwind_info_len);
        <D.27261>:
        frame->unwind_info = unwind_info;
        unwind_info_len.2080 = unwind_info_len;
        frame->unwind_info_len = unwind_info_len.2080;
        D.27264 = new_ctx->rax;
        regs[0] = D.27264;
        D.27265 = new_ctx->rbx;
        regs[3] = D.27265;
        D.27266 = new_ctx->rcx;
        regs[1] = D.27266;
        D.27267 = new_ctx->rdx;
        regs[2] = D.27267;
        D.27268 = new_ctx->rbp;
        regs[5] = D.27268;
        D.27269 = new_ctx->rsp;
        regs[4] = D.27269;
        D.27270 = new_ctx->rsi;
        regs[6] = D.27270;
        D.27271 = new_ctx->rdi;
        regs[7] = D.27271;
        D.27272 = new_ctx->rip;
        regs[16] = D.27272;
        D.27273 = new_ctx->r12;
        regs[12] = D.27273;
        D.27274 = new_ctx->r13;
        regs[13] = D.27274;
        D.27275 = new_ctx->r14;
        regs[14] = D.27275;
        D.27276 = new_ctx->r15;
        regs[15] = D.27276;
        D.27277 = ji->code_start;
        D.27278 = ji->code_size;
        D.27279 = (sizetype) D.27278;
        D.27280 = D.27277 + D.27279;
        D.27277 = ji->code_start;
        unwind_info_len.2080 = unwind_info_len;
        mono_unwind_frame (unwind_info, unwind_info_len.2080, D.27277, D.27280, ip, &regs, 17, save_locations, 16, &cfa);
        D.27281 = regs[0];
        new_ctx->rax = D.27281;
        D.27282 = regs[3];
        new_ctx->rbx = D.27282;
        D.27283 = regs[1];
        new_ctx->rcx = D.27283;
        D.27284 = regs[2];
        new_ctx->rdx = D.27284;
        D.27285 = regs[5];
        new_ctx->rbp = D.27285;
        D.27286 = regs[4];
        new_ctx->rsp = D.27286;
        D.27287 = regs[6];
        new_ctx->rsi = D.27287;
        D.27288 = regs[7];
        new_ctx->rdi = D.27288;
        D.27289 = regs[16];
        new_ctx->rip = D.27289;
        D.27290 = regs[12];
        new_ctx->r12 = D.27290;
        D.27291 = regs[13];
        new_ctx->r13 = D.27291;
        D.27292 = regs[14];
        new_ctx->r14 = D.27292;
        D.27293 = regs[15];
        new_ctx->r15 = D.27293;
        cfa.2081 = cfa;
        cfa.2082 = (long int) cfa.2081;
        new_ctx->rsp = cfa.2082;
        D.27272 = new_ctx->rip;
        D.27296 = D.27272 + -1;
        new_ctx->rip = D.27296;
        D.27297 = *lmf;
        if (D.27297 != 0B) goto <D.27298>; else goto <D.27299>;
        <D.27298>:
        D.27297 = *lmf;
        D.27300 = jit_tls->first_lmf;
        if (D.27297 != D.27300) goto <D.27301>; else goto <D.27302>;
        <D.27301>:
        D.27303 = ctx->rsp;
        D.27304 = (void *) D.27303;
        D.27297 = *lmf;
        D.27305 = D.27297->rsp;
        D.27306 = (void *) D.27305;
        if (D.27304 >= D.27306) goto <D.27307>; else goto <D.27308>;
        <D.27307>:
        D.27297 = *lmf;
        D.27309 = D.27297->previous_lmf;
        D.27310 = (long unsigned int) D.27309;
        D.27311 = D.27310 & 18446744073709551608;
        D.27312 = (struct MonoLMF *) D.27311;
        *lmf = D.27312;
        <D.27308>:
        <D.27302>:
        <D.27299>:
        D.27313 = 1;
        return D.27313;
      }
    finally
      {
        regs = {CLOBBER};
        cfa = {CLOBBER};
        unwind_info_len = {CLOBBER};
      }
  }
  <D.27256>:
  D.27297 = *lmf;
  if (D.27297 != 0B) goto <D.27314>; else goto <D.27315>;
  <D.27314>:
  {
    guint64 rip;

    D.27297 = *lmf;
    D.27309 = D.27297->previous_lmf;
    D.27310 = (long unsigned int) D.27309;
    D.27316 = D.27310 & 2;
    if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
    <D.27317>:
    {
      struct MonoLMFExt * ext;

      ext = *lmf;
      D.27319 = ext->debugger_invoke;
      D.27320 = D.27319 == 0;
      D.27321 = (long int) D.27320;
      D.27322 = __builtin_expect (D.27321, 0);
      if (D.27322 != 0) goto <D.27323>; else goto <D.27324>;
      <D.27323>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 670, "ext->debugger_invoke");
      <D.27324>:
      D.27325 = &ext->ctx;
      memcpy (new_ctx, D.27325, 136);
      D.27297 = *lmf;
      D.27309 = D.27297->previous_lmf;
      D.27310 = (long unsigned int) D.27309;
      D.27311 = D.27310 & 18446744073709551608;
      D.27312 = (struct MonoLMF *) D.27311;
      *lmf = D.27312;
      frame->type = 1;
      D.27313 = 1;
      return D.27313;
    }
    <D.27318>:
    D.27297 = *lmf;
    D.27309 = D.27297->previous_lmf;
    D.27310 = (long unsigned int) D.27309;
    D.27326 = D.27310 & 1;
    if (D.27326 != 0) goto <D.27327>; else goto <D.27328>;
    <D.27327>:
    D.27297 = *lmf;
    rip = D.27297->rip;
    goto <D.27329>;
    <D.27328>:
    D.27297 = *lmf;
    D.27305 = D.27297->rsp;
    if (D.27305 == 0) goto <D.27330>; else goto <D.27331>;
    <D.27330>:
    D.27313 = 0;
    return D.27313;
    <D.27331>:
    D.27297 = *lmf;
    D.27305 = D.27297->rsp;
    D.27332 = D.27305 + 18446744073709551608;
    D.27333 = (guint64 *) D.27332;
    rip = *D.27333;
    <D.27329>:
    rip.2083 = (char *) rip;
    ji = mini_jit_info_table_find (domain, rip.2083, 0B);
    if (ji == 0B) goto <D.27335>; else goto <D.27336>;
    <D.27335>:
    D.27313 = 0;
    return D.27313;
    <D.27336>:
    rip = rip + 18446744073709551615;
    frame->ji = ji;
    frame->type = 2;
    rip.2084 = (long int) rip;
    new_ctx->rip = rip.2084;
    D.27297 = *lmf;
    D.27338 = D.27297->rbp;
    D.27339 = (long int) D.27338;
    new_ctx->rbp = D.27339;
    D.27297 = *lmf;
    D.27305 = D.27297->rsp;
    D.27340 = (long int) D.27305;
    new_ctx->rsp = D.27340;
    D.27297 = *lmf;
    D.27309 = D.27297->previous_lmf;
    D.27310 = (long unsigned int) D.27309;
    D.27341 = D.27310 & 4;
    if (D.27341 != 0) goto <D.27342>; else goto <D.27343>;
    <D.27342>:
    {
      struct MonoLMFTramp * ext;

      ext = *lmf;
      D.27344 = ext->regs;
      D.27345 = D.27344 + 24;
      D.27346 = *D.27345;
      D.27347 = (long int) D.27346;
      new_ctx->rbx = D.27347;
      D.27344 = ext->regs;
      D.27348 = D.27344 + 96;
      D.27349 = *D.27348;
      D.27350 = (long int) D.27349;
      new_ctx->r12 = D.27350;
      D.27344 = ext->regs;
      D.27351 = D.27344 + 104;
      D.27352 = *D.27351;
      D.27353 = (long int) D.27352;
      new_ctx->r13 = D.27353;
      D.27344 = ext->regs;
      D.27354 = D.27344 + 112;
      D.27355 = *D.27354;
      D.27356 = (long int) D.27355;
      new_ctx->r14 = D.27356;
      D.27344 = ext->regs;
      D.27357 = D.27344 + 120;
      D.27358 = *D.27357;
      D.27359 = (long int) D.27358;
      new_ctx->r15 = D.27359;
    }
    goto <D.27360>;
    <D.27343>:
    new_ctx->rbx = 0;
    new_ctx->r12 = 0;
    new_ctx->r13 = 0;
    new_ctx->r14 = 0;
    new_ctx->r15 = 0;
    <D.27360>:
    D.27297 = *lmf;
    D.27309 = D.27297->previous_lmf;
    D.27310 = (long unsigned int) D.27309;
    D.27311 = D.27310 & 18446744073709551608;
    D.27312 = (struct MonoLMF *) D.27311;
    *lmf = D.27312;
    D.27313 = 1;
    return D.27313;
  }
  <D.27315>:
  D.27313 = 0;
  return D.27313;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.27365;
  int D.27370;
  void * D.27372;
  long unsigned int D.27373;

  D.27365 = __builtin_constant_p (__len);
  if (D.27365 != 0) goto <D.27366>; else goto <D.27367>;
  <D.27366>:
  if (__len == 0) goto <D.27368>; else goto <D.27369>;
  <D.27368>:
  D.27370 = __builtin_constant_p (__ch);
  if (D.27370 == 0) goto <D.27363>; else goto <D.27371>;
  <D.27371>:
  if (__ch != 0) goto <D.27363>; else goto <D.27364>;
  <D.27363>:
  __warn_memset_zero_len ();
  D.27372 = __dest;
  return D.27372;
  <D.27364>:
  <D.27369>:
  <D.27367>:
  D.27373 = __builtin_object_size (__dest, 0);
  D.27372 = __builtin___memset_chk (__dest, __ch, __len, D.27373);
  return D.27372;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.27375;
  long unsigned int D.27376;

  D.27376 = __builtin_object_size (__dest, 0);
  D.27375 = __builtin___memcpy_chk (__dest, __src, __len, D.27376);
  return D.27375;
}


mono_arch_setup_async_callback (struct MonoContext * ctx, void (*<Tc2>) (void *) async_cb, void * user_data)
{
  long int D.27378;
  long int user_data.2085;
  long unsigned int D.27380;
  guint64 * sp.2086;
  long int D.27384;
  long unsigned int D.27385;
  long int sp.2087;
  long int async_cb.2088;
  guint64 sp;

  D.27378 = ctx->rsp;
  sp = (guint64) D.27378;
  user_data.2085 = (long int) user_data;
  ctx->rdi = user_data.2085;
  sp = sp + 18446744073709551488;
  D.27380 = sp & 15;
  if (D.27380 == 0) goto <D.27381>; else goto <D.27382>;
  <D.27381>:
  sp = sp + 18446744073709551608;
  <D.27382>:
  sp.2086 = (guint64 *) sp;
  D.27384 = ctx->rip;
  D.27385 = (long unsigned int) D.27384;
  *sp.2086 = D.27385;
  sp.2087 = (long int) sp;
  ctx->rsp = sp.2087;
  async_cb.2088 = (long int) async_cb;
  ctx->rip = async_cb.2088;
}


mono_arch_handle_exception (void * sigctx, void * obj)
{
  unsigned int mono_jit_tls_id.2089;
  struct MonoContext * D.27389;
  gboolean D.27390;
  struct MonoContext mctx;
  struct MonoJitTlsData * jit_tls;

  try
    {
      mono_jit_tls_id.2089 = mono_jit_tls_id;
      jit_tls = pthread_getspecific (mono_jit_tls_id.2089);
      D.27389 = &jit_tls->ex_ctx;
      mono_arch_sigctx_to_monoctx (sigctx, D.27389);
      mctx = jit_tls->ex_ctx;
      mono_arch_setup_async_callback (&mctx, handle_signal_exception, obj);
      mono_monoctx_to_sigctx (&mctx, sigctx);
      D.27390 = 1;
      return D.27390;
    }
  finally
    {
      mctx = {CLOBBER};
    }
}


handle_signal_exception (void * obj)
{
  unsigned int mono_jit_tls_id.2090;
  struct MonoContext * D.27394;
  struct MonoJitTlsData * jit_tls;
  struct MonoContext ctx;

  try
    {
      mono_jit_tls_id.2090 = mono_jit_tls_id;
      jit_tls = pthread_getspecific (mono_jit_tls_id.2090);
      D.27394 = &jit_tls->ex_ctx;
      memcpy (&ctx, D.27394, 136);
      mono_handle_exception (&ctx, obj);
      mono_restore_context (&ctx);
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


mono_arch_sigctx_to_monoctx (void * sigctx, struct MonoContext * mctx)
{
  mono_sigctx_to_monoctx (sigctx, mctx);
}


mono_arch_monoctx_to_sigctx (struct MonoContext * mctx, void * sigctx)
{
  mono_monoctx_to_sigctx (mctx, sigctx);
}


mono_arch_ip_from_context (void * sigctx)
{
  void * D.27395;
  greg_t * D.27396;
  long unsigned int D.27397;
  struct ucontext_t * ctx;

  ctx = sigctx;
  D.27396 = &ctx->uc_mcontext.gregs[16];
  D.27397 = MEM[(guint64 *)D.27396];
  D.27395 = (void *) D.27397;
  return D.27395;
}


mono_arch_handle_altstack_exception (void * sigctx, void * fault_addr, gboolean stack_ovf)
{
  greg_t * D.27399;
  long unsigned int D.27400;
  char * D.27401;
  struct MonoDomain * D.27402;
  struct MonoDomain * D.27405;
  greg_t * D.27408;
  long unsigned int D.27409;
  long unsigned int D.27410;
  sizetype D.27411;
  sizetype D.27412;
  void * * D.27413;
  void * D.27414;
  long unsigned int altstack_handle_and_restore.2091;
  long unsigned int D.27416;
  greg_t * D.27417;
  long unsigned int copied_ctx.2092;
  greg_t * D.27419;
  long unsigned int exc.2093;
  greg_t * D.27421;
  long unsigned int D.27422;
  struct MonoException * exc;
  struct ucontext_t * ctx;
  struct MonoJitInfo * ji;
  void * * sp;
  int frame_size;
  struct ucontext_t * copied_ctx;

  exc = 0B;
  ctx = sigctx;
  D.27399 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[16];
  D.27400 = MEM[(guint64 *)D.27399];
  D.27401 = (char *) D.27400;
  D.27402 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.27402, D.27401, 0B);
  if (stack_ovf != 0) goto <D.27403>; else goto <D.27404>;
  <D.27403>:
  D.27405 = mono_domain_get ();
  exc = D.27405->stack_overflow_ex;
  <D.27404>:
  if (ji == 0B) goto <D.27406>; else goto <D.27407>;
  <D.27406>:
  mono_handle_native_sigsegv (11, sigctx);
  <D.27407>:
  frame_size = 1096;
  frame_size = frame_size + 15;
  frame_size = frame_size & -16;
  D.27408 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[15];
  D.27409 = MEM[(guint64 *)D.27408];
  D.27410 = D.27409 & 18446744073709551600;
  sp = (void * *) D.27410;
  D.27411 = (sizetype) frame_size;
  D.27412 = -D.27411;
  sp = sp + D.27412;
  copied_ctx = sp + 32;
  D.27413 = sp + 18446744073709551608;
  D.27399 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[16];
  D.27400 = MEM[(guint64 *)D.27399];
  D.27414 = (void *) D.27400;
  *D.27413 = D.27414;
  memcpy (copied_ctx, ctx, 936);
  D.27399 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[16];
  altstack_handle_and_restore.2091 = (long unsigned int) altstack_handle_and_restore;
  MEM[(guint64 *)D.27399] = altstack_handle_and_restore.2091;
  D.27408 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[15];
  D.27413 = sp + 18446744073709551608;
  D.27416 = (long unsigned int) D.27413;
  MEM[(guint64 *)D.27408] = D.27416;
  D.27417 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[8];
  copied_ctx.2092 = (long unsigned int) copied_ctx;
  MEM[(guint64 *)D.27417] = copied_ctx.2092;
  D.27419 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[9];
  exc.2093 = (long unsigned int) exc;
  MEM[(guint64 *)D.27419] = exc.2093;
  D.27421 = &MEM[(struct ucontext_t *)sigctx].uc_mcontext.gregs[12];
  D.27422 = (long unsigned int) stack_ovf;
  MEM[(guint64 *)D.27421] = D.27422;
}


altstack_handle_and_restore (void * sigctx, void * obj, gboolean stack_ovf)
{
  struct MonoContext mctx;

  try
    {
      mono_arch_sigctx_to_monoctx (sigctx, &mctx);
      mono_handle_exception (&mctx, obj);
      if (stack_ovf != 0) goto <D.27423>; else goto <D.27424>;
      <D.27423>:
      prepare_for_guard_pages (&mctx);
      <D.27424>:
      mono_restore_context (&mctx);
    }
  finally
    {
      mctx = {CLOBBER};
    }
}


prepare_for_guard_pages (struct MonoContext * mctx)
{
  long int D.27425;
  long int D.27426;
  void * D.27427;
  long int restore_soft_guard_pages.2094;
  long int sp.2095;
  void * * sp;

  D.27425 = mctx->rsp;
  sp = (void * *) D.27425;
  sp = sp + 18446744073709551608;
  D.27426 = mctx->rip;
  D.27427 = (void *) D.27426;
  *sp = D.27427;
  restore_soft_guard_pages.2094 = (long int) restore_soft_guard_pages;
  mctx->rip = restore_soft_guard_pages.2094;
  sp.2095 = (long int) sp;
  mctx->rsp = sp.2095;
}


restore_soft_guard_pages ()
{
  unsigned int mono_jit_tls_id.2096;
  void * D.27431;
  unsigned int D.27434;
  long unsigned int D.27435;
  struct MonoJitTlsData * jit_tls;

  mono_jit_tls_id.2096 = mono_jit_tls_id;
  jit_tls = pthread_getspecific (mono_jit_tls_id.2096);
  D.27431 = jit_tls->stack_ovf_guard_base;
  if (D.27431 != 0B) goto <D.27432>; else goto <D.27433>;
  <D.27432>:
  D.27434 = jit_tls->stack_ovf_guard_size;
  D.27435 = (long unsigned int) D.27434;
  D.27431 = jit_tls->stack_ovf_guard_base;
  mono_mprotect (D.27431, D.27435, 0);
  <D.27433>:
}


mono_amd64_get_original_ip ()
{
  _Bool D.27436;
  long int D.27437;
  long int D.27438;
  void * D.27441;
  long unsigned int D.27442;
  long unsigned int D.27443;
  void * D.27444;
  guint64 D.27445;
  struct MonoLMF * lmf;

  lmf = mono_get_lmf ();
  D.27436 = lmf == 0B;
  D.27437 = (long int) D.27436;
  D.27438 = __builtin_expect (D.27437, 0);
  if (D.27438 != 0) goto <D.27439>; else goto <D.27440>;
  <D.27439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 953, "lmf");
  <D.27440>:
  D.27441 = lmf->previous_lmf;
  D.27442 = (long unsigned int) D.27441;
  D.27443 = D.27442 & 18446744073709551614;
  D.27444 = (void *) D.27443;
  lmf->previous_lmf = D.27444;
  D.27445 = lmf->rip;
  return D.27445;
}


mono_arch_get_throw_pending_exception (struct MonoTrampInfo * * info, gboolean aot)
{
  int kMaxCodeSize.2097;
  void * code.2098;
  guint8 * code.2099;
  guint8 * code.2100;
  guint8 * code.2101;
  unsigned char D.27454;
  guint8 * code.2102;
  guint8 * code.2103;
  guint8 * code.2104;
  guint8 * code.2105;
  unsigned char D.27461;
  guint8 * code.2106;
  guint8 * code.2107;
  guint8 * code.2108;
  guint8 * code.2109;
  unsigned char D.27470;
  guint8 * code.2110;
  guint8 * code.2111;
  guint8 * code.2112;
  guint8 * code.2113;
  guint8 * code.2114;
  guint8 * code.2115;
  guint8 * code.2116;
  unsigned char D.27483;
  guint8 * code.2117;
  guint8 * code.2118;
  guint8 * code.2119;
  guint8 * code.2120;
  unsigned char D.27488;
  guint8 * code.2121;
  guint8 * code.2122;
  unsigned char D.27491;
  guint8 * code.2123;
  guint8 * code.2124;
  unsigned char D.27494;
  guint8 * code.2125;
  guint8 * code.2126;
  unsigned char D.27497;
  guint8 * code.2127;
  guint8 * code.2128;
  unsigned char D.27503;
  guint8 * code.2129;
  guint8 * code.2130;
  guint8 * code.2131;
  guint8 * code.2132;
  guint8 * code.2133;
  guint8 * code.2134;
  unsigned char D.27510;
  guint8 * code.2135;
  guint8 * code.2136;
  unsigned char D.27513;
  guint8 * code.2137;
  guint8 * code.2138;
  unsigned char D.27516;
  guint8 * code.2139;
  guint8 * code.2140;
  unsigned char D.27519;
  guint8 * code.2141;
  guint8 * code.2142;
  guint8 * code.2143;
  guint8 * code.2144;
  unsigned char D.27526;
  guint8 * code.2145;
  guint8 * code.2146;
  guint8 * code.2147;
  guint8 * code.2148;
  guint8 * code.2149;
  guint8 * code.2150;
  guint8 * code.2151;
  guint8 * code.2152;
  guint8 * code.2153;
  guint8 * code.2154;
  guint8 * code.2155;
  guint8 * code.2156;
  guint8 * code.2157;
  guint8 * code.2158;
  guint8 * code.2159;
  guint8 * code.2160;
  guint8 * code.2161;
  guint8 * code.2162;
  unsigned char D.27553;
  guint8 * code.2163;
  guint8 * code.2164;
  unsigned char D.27556;
  guint8 * code.2165;
  guint8 * code.2166;
  unsigned char D.27559;
  guint8 * code.2167;
  guint8 * code.2168;
  unsigned char D.27562;
  guint8 * code.2169;
  guint8 * code.2170;
  guint8 * code.2171;
  guint8 * code.2172;
  guint8 * code.2173;
  guint8 * code.2174;
  guint8 * code.2175;
  guint8 * code.2176;
  unsigned char D.27576;
  guint8 * code.2177;
  guint8 * code.2178;
  unsigned char D.27579;
  guint8 * code.2179;
  guint8 * code.2180;
  unsigned char D.27582;
  guint8 * code.2181;
  guint8 * code.2182;
  unsigned char D.27585;
  guint8 * code.2183;
  guint8 * code.2184;
  unsigned char D.27592;
  guint8 * code.2185;
  guint8 * code.2186;
  guint8 * code.2187;
  guint8 * code.2188;
  guint8 * code.2189;
  guint8 * code.2190;
  unsigned char D.27604;
  guint8 * code.2191;
  guint8 * code.2192;
  guint8 * code.2193;
  guint8 * code.2194;
  unsigned char D.27609;
  guint8 * code.2195;
  guint8 * code.2196;
  unsigned char D.27612;
  guint8 * code.2197;
  guint8 * code.2198;
  unsigned char D.27615;
  guint8 * code.2199;
  guint8 * code.2200;
  unsigned char D.27618;
  guint8 * code.2201;
  guint8 * code.2202;
  unsigned char D.27624;
  guint8 * code.2203;
  guint8 * code.2204;
  guint8 * code.2205;
  guint8 * code.2206;
  guint8 * code.2207;
  guint8 * code.2208;
  unsigned char D.27631;
  guint8 * code.2209;
  guint8 * code.2210;
  unsigned char D.27634;
  guint8 * code.2211;
  guint8 * code.2212;
  unsigned char D.27637;
  guint8 * code.2213;
  guint8 * code.2214;
  unsigned char D.27640;
  long int code.2215;
  guint8 * start.2216;
  long int start.2217;
  long int D.27646;
  int D.27647;
  guint8 * code.2218;
  guint8 * code.2219;
  guint8 * code.2220;
  guint8 * code.2221;
  unsigned char D.27656;
  guint8 * code.2222;
  guint8 * code.2223;
  guint8 * code.2224;
  guint8 * code.2225;
  guint8 * code.2226;
  guint8 * code.2227;
  guint8 * code.2228;
  guint8 * code.2229;
  unsigned char D.27667;
  guint8 * code.2230;
  guint8 * code.2231;
  unsigned char D.27670;
  guint8 * code.2232;
  guint8 * code.2233;
  unsigned char D.27673;
  guint8 * code.2234;
  guint8 * code.2235;
  unsigned char D.27676;
  guint8 * code.2236;
  guint8 * code.2237;
  guint8 * code.2238;
  guint8 * code.2239;
  guint8 * code.2240;
  guint8 * code.2241;
  guint8 * code.2242;
  guint8 * code.2243;
  guint8 * code.2244;
  guint8 * code.2245;
  guint8 * code.2246;
  guint8 * code.2247;
  guint8 * code.2248;
  guint8 * code.2249;
  unsigned char D.27700;
  guint8 * code.2250;
  guint8 * code.2251;
  unsigned char D.27703;
  guint8 * code.2252;
  guint8 * code.2253;
  unsigned char D.27706;
  guint8 * code.2254;
  guint8 * code.2255;
  unsigned char D.27709;
  guint8 * code.2256;
  guint8 * code.2257;
  guint8 * code.2258;
  guint8 * code.2259;
  guint8 * code.2260;
  guint8 * code.2261;
  guint8 * code.2262;
  guint8 * code.2263;
  unsigned char D.27723;
  guint8 * code.2264;
  guint8 * code.2265;
  unsigned char D.27726;
  guint8 * code.2266;
  guint8 * code.2267;
  unsigned char D.27729;
  guint8 * code.2268;
  guint8 * code.2269;
  unsigned char D.27732;
  long int mono_thread_get_and_clear_pending_exception.2270;
  int D.27735;
  long unsigned int D.27736;
  long unsigned int mono_thread_get_and_clear_pending_exception.2271;
  _Bool D.27738;
  unsigned char iftmp.2272;
  guint8 * code.2273;
  guint8 * code.2274;
  unsigned char D.27747;
  guint8 * code.2275;
  guint8 * code.2276;
  guint8 * code.2277;
  guint8 * code.2278;
  unsigned char D.27754;
  guint8 * code.2279;
  guint8 * code.2280;
  unsigned char D.27757;
  guint8 * code.2281;
  guint8 * code.2282;
  unsigned char D.27760;
  guint8 * code.2283;
  guint8 * code.2284;
  unsigned char D.27763;
  guint8 * code.2285;
  guint8 * code.2286;
  unsigned char D.27766;
  guint8 * code.2287;
  guint8 * code.2288;
  unsigned char D.27769;
  guint8 * code.2289;
  guint8 * code.2290;
  unsigned char D.27772;
  guint8 * code.2291;
  guint8 * code.2292;
  unsigned char D.27775;
  guint8 * code.2293;
  guint8 * code.2294;
  unsigned char D.27779;
  guint8 * code.2295;
  guint8 * code.2296;
  unsigned char D.27782;
  guint8 * code.2297;
  guint8 * code.2298;
  unsigned char D.27785;
  guint8 * code.2299;
  guint8 * code.2300;
  unsigned char D.27788;
  guint8 * code.2301;
  guint8 * code.2302;
  unsigned char D.27793;
  guint8 * code.2303;
  guint8 * code.2304;
  guint8 * code.2305;
  guint8 * code.2306;
  guint8 * code.2307;
  guint8 * code.2308;
  unsigned char D.27804;
  guint8 * code.2309;
  guint8 * code.2310;
  guint8 * code.2311;
  guint8 * code.2312;
  guint8 * code.2313;
  guint8 * code.2314;
  unsigned char D.27816;
  guint8 * code.2315;
  guint8 * code.2316;
  guint8 * code.2317;
  guint8 * code.2318;
  unsigned char D.27821;
  guint8 * code.2319;
  guint8 * code.2320;
  unsigned char D.27824;
  guint8 * code.2321;
  guint8 * code.2322;
  unsigned char D.27827;
  guint8 * code.2323;
  guint8 * code.2324;
  unsigned char D.27830;
  guint8 * code.2325;
  guint8 * code.2326;
  unsigned char D.27836;
  guint8 * code.2327;
  guint8 * code.2328;
  guint8 * code.2329;
  guint8 * code.2330;
  guint8 * code.2331;
  guint8 * code.2332;
  unsigned char D.27843;
  guint8 * code.2333;
  guint8 * code.2334;
  unsigned char D.27846;
  guint8 * code.2335;
  guint8 * code.2336;
  unsigned char D.27849;
  guint8 * code.2337;
  guint8 * code.2338;
  unsigned char D.27852;
  guint8 * code.2339;
  guint8 * code.2340;
  unsigned char D.27857;
  guint8 * code.2341;
  guint8 * code.2342;
  unsigned char D.27861;
  guint8 * code.2343;
  guint8 * code.2344;
  unsigned char D.27866;
  guint8 * code.2345;
  guint8 * code.2346;
  guint8 * code.2347;
  guint8 * code.2348;
  unsigned char D.27875;
  guint8 * code.2349;
  guint8 * code.2350;
  guint8 * code.2351;
  guint8 * code.2352;
  guint8 * code.2353;
  guint8 * code.2354;
  unsigned char D.27887;
  guint8 * code.2355;
  guint8 * code.2356;
  guint8 * code.2357;
  guint8 * code.2358;
  unsigned char D.27892;
  guint8 * code.2359;
  guint8 * code.2360;
  unsigned char D.27895;
  guint8 * code.2361;
  guint8 * code.2362;
  unsigned char D.27898;
  guint8 * code.2363;
  guint8 * code.2364;
  unsigned char D.27901;
  guint8 * code.2365;
  guint8 * code.2366;
  unsigned char D.27907;
  guint8 * code.2367;
  guint8 * code.2368;
  guint8 * code.2369;
  guint8 * code.2370;
  guint8 * code.2371;
  guint8 * code.2372;
  unsigned char D.27914;
  guint8 * code.2373;
  guint8 * code.2374;
  unsigned char D.27917;
  guint8 * code.2375;
  guint8 * code.2376;
  unsigned char D.27920;
  guint8 * code.2377;
  guint8 * code.2378;
  unsigned char D.27923;
  guint8 * code.2379;
  guint8 * code.2380;
  guint8 * code.2381;
  guint8 * code.2382;
  unsigned char D.27934;
  guint8 * code.2383;
  guint8 * code.2384;
  guint8 * code.2385;
  guint8 * code.2386;
  guint8 * code.2387;
  guint8 * code.2388;
  guint8 * code.2389;
  guint8 * code.2390;
  unsigned char D.27945;
  guint8 * code.2391;
  guint8 * code.2392;
  unsigned char D.27948;
  guint8 * code.2393;
  guint8 * code.2394;
  unsigned char D.27951;
  guint8 * code.2395;
  guint8 * code.2396;
  unsigned char D.27954;
  guint8 * code.2397;
  guint8 * code.2398;
  guint8 * code.2399;
  guint8 * code.2400;
  guint8 * code.2401;
  guint8 * code.2402;
  guint8 * code.2403;
  guint8 * code.2404;
  guint8 * code.2405;
  guint8 * code.2406;
  guint8 * code.2407;
  guint8 * code.2408;
  guint8 * code.2409;
  guint8 * code.2410;
  unsigned char D.27978;
  guint8 * code.2411;
  guint8 * code.2412;
  unsigned char D.27981;
  guint8 * code.2413;
  guint8 * code.2414;
  unsigned char D.27984;
  guint8 * code.2415;
  guint8 * code.2416;
  unsigned char D.27987;
  guint8 * code.2417;
  guint8 * code.2418;
  guint8 * code.2419;
  guint8 * code.2420;
  guint8 * code.2421;
  guint8 * code.2422;
  guint8 * code.2423;
  guint8 * code.2424;
  unsigned char D.28001;
  guint8 * code.2425;
  guint8 * code.2426;
  unsigned char D.28004;
  guint8 * code.2427;
  guint8 * code.2428;
  unsigned char D.28007;
  guint8 * code.2429;
  guint8 * code.2430;
  unsigned char D.28010;
  long int mono_amd64_get_original_ip.2431;
  int D.28013;
  long unsigned int D.28014;
  long unsigned int mono_amd64_get_original_ip.2432;
  _Bool D.28016;
  unsigned char iftmp.2433;
  guint8 * code.2434;
  guint8 * code.2435;
  unsigned char D.28025;
  guint8 * code.2436;
  guint8 * code.2437;
  guint8 * code.2438;
  guint8 * code.2439;
  unsigned char D.28032;
  guint8 * code.2440;
  guint8 * code.2441;
  unsigned char D.28035;
  guint8 * code.2442;
  guint8 * code.2443;
  unsigned char D.28038;
  guint8 * code.2444;
  guint8 * code.2445;
  unsigned char D.28041;
  guint8 * code.2446;
  guint8 * code.2447;
  unsigned char D.28044;
  guint8 * code.2448;
  guint8 * code.2449;
  unsigned char D.28047;
  guint8 * code.2450;
  guint8 * code.2451;
  unsigned char D.28050;
  guint8 * code.2452;
  guint8 * code.2453;
  unsigned char D.28053;
  guint8 * code.2454;
  guint8 * code.2455;
  unsigned char D.28057;
  guint8 * code.2456;
  guint8 * code.2457;
  unsigned char D.28060;
  guint8 * code.2458;
  guint8 * code.2459;
  unsigned char D.28063;
  guint8 * code.2460;
  guint8 * code.2461;
  unsigned char D.28066;
  guint8 * code.2462;
  guint8 * code.2463;
  unsigned char D.28071;
  guint8 * code.2464;
  guint8 * code.2465;
  guint8 * code.2466;
  guint8 * code.2467;
  guint8 * code.2468;
  guint8 * code.2469;
  guint8 * code.2470;
  guint8 * code.2471;
  unsigned char D.28084;
  guint8 * code.2472;
  guint8 * code.2473;
  guint8 * code.2474;
  guint8 * code.2475;
  guint8 * code.2476;
  guint8 * code.2477;
  guint8 * code.2478;
  guint8 * code.2479;
  unsigned char D.28095;
  guint8 * code.2480;
  guint8 * code.2481;
  unsigned char D.28098;
  guint8 * code.2482;
  guint8 * code.2483;
  unsigned char D.28101;
  guint8 * code.2484;
  guint8 * code.2485;
  unsigned char D.28104;
  guint8 * code.2486;
  guint8 * code.2487;
  guint8 * code.2488;
  guint8 * code.2489;
  guint8 * code.2490;
  guint8 * code.2491;
  guint8 * code.2492;
  guint8 * code.2493;
  guint8 * code.2494;
  guint8 * code.2495;
  guint8 * code.2496;
  guint8 * code.2497;
  guint8 * code.2498;
  guint8 * code.2499;
  unsigned char D.28128;
  guint8 * code.2500;
  guint8 * code.2501;
  unsigned char D.28131;
  guint8 * code.2502;
  guint8 * code.2503;
  unsigned char D.28134;
  guint8 * code.2504;
  guint8 * code.2505;
  unsigned char D.28137;
  guint8 * code.2506;
  guint8 * code.2507;
  guint8 * code.2508;
  guint8 * code.2509;
  guint8 * code.2510;
  guint8 * code.2511;
  guint8 * code.2512;
  guint8 * code.2513;
  unsigned char D.28151;
  guint8 * code.2514;
  guint8 * code.2515;
  unsigned char D.28154;
  guint8 * code.2516;
  guint8 * code.2517;
  unsigned char D.28157;
  guint8 * code.2518;
  guint8 * code.2519;
  unsigned char D.28160;
  guint8 * code.2520;
  guint8 * code.2521;
  unsigned char D.28167;
  guint8 * code.2522;
  guint8 * code.2523;
  guint8 * code.2524;
  guint8 * code.2525;
  guint8 * code.2526;
  guint8 * code.2527;
  unsigned char D.28179;
  guint8 * code.2528;
  guint8 * code.2529;
  guint8 * code.2530;
  guint8 * code.2531;
  unsigned char D.28184;
  guint8 * code.2532;
  guint8 * code.2533;
  unsigned char D.28187;
  guint8 * code.2534;
  guint8 * code.2535;
  unsigned char D.28190;
  guint8 * code.2536;
  guint8 * code.2537;
  unsigned char D.28193;
  guint8 * code.2538;
  guint8 * code.2539;
  unsigned char D.28199;
  guint8 * code.2540;
  guint8 * code.2541;
  guint8 * code.2542;
  guint8 * code.2543;
  guint8 * code.2544;
  guint8 * code.2545;
  unsigned char D.28206;
  guint8 * code.2546;
  guint8 * code.2547;
  unsigned char D.28209;
  guint8 * code.2548;
  guint8 * code.2549;
  unsigned char D.28212;
  guint8 * code.2550;
  guint8 * code.2551;
  unsigned char D.28215;
  guint8 * code.2552;
  guint8 * code.2553;
  guint8 * code.2554;
  guint8 * code.2555;
  unsigned char D.28224;
  guint8 * code.2556;
  guint8 * code.2557;
  guint8 * code.2558;
  guint8 * code.2559;
  guint8 * code.2560;
  guint8 * code.2561;
  guint8 * code.2562;
  guint8 * code.2563;
  unsigned char D.28235;
  guint8 * code.2564;
  guint8 * code.2565;
  guint8 * code.2566;
  guint8 * code.2567;
  guint8 * code.2568;
  guint8 * code.2569;
  unsigned char D.28248;
  guint8 * code.2570;
  guint8 * code.2571;
  guint8 * code.2572;
  guint8 * code.2573;
  guint8 * code.2574;
  guint8 * code.2575;
  guint8 * code.2576;
  guint8 * code.2577;
  unsigned char D.28259;
  guint8 * code.2578;
  guint8 * code.2579;
  unsigned char D.28262;
  guint8 * code.2580;
  guint8 * code.2581;
  unsigned char D.28265;
  guint8 * code.2582;
  guint8 * code.2583;
  unsigned char D.28268;
  guint8 * code.2584;
  guint8 * code.2585;
  guint8 * code.2586;
  guint8 * code.2587;
  guint8 * code.2588;
  guint8 * code.2589;
  guint8 * code.2590;
  guint8 * code.2591;
  guint8 * code.2592;
  guint8 * code.2593;
  guint8 * code.2594;
  guint8 * code.2595;
  guint8 * code.2596;
  guint8 * code.2597;
  unsigned char D.28292;
  guint8 * code.2598;
  guint8 * code.2599;
  unsigned char D.28295;
  guint8 * code.2600;
  guint8 * code.2601;
  unsigned char D.28298;
  guint8 * code.2602;
  guint8 * code.2603;
  unsigned char D.28301;
  guint8 * code.2604;
  guint8 * code.2605;
  guint8 * code.2606;
  guint8 * code.2607;
  guint8 * code.2608;
  guint8 * code.2609;
  guint8 * code.2610;
  guint8 * code.2611;
  unsigned char D.28315;
  guint8 * code.2612;
  guint8 * code.2613;
  unsigned char D.28318;
  guint8 * code.2614;
  guint8 * code.2615;
  unsigned char D.28321;
  guint8 * code.2616;
  guint8 * code.2617;
  unsigned char D.28324;
  long unsigned int throw_trampoline.2618;
  long int throw_trampoline.2619;
  int D.28328;
  long unsigned int D.28329;
  _Bool D.28330;
  unsigned char iftmp.2620;
  guint8 * code.2621;
  guint8 * code.2622;
  unsigned char D.28339;
  guint8 * code.2623;
  guint8 * code.2624;
  guint8 * code.2625;
  guint8 * code.2626;
  unsigned char D.28346;
  guint8 * code.2627;
  guint8 * code.2628;
  unsigned char D.28349;
  guint8 * code.2629;
  guint8 * code.2630;
  unsigned char D.28352;
  guint8 * code.2631;
  guint8 * code.2632;
  unsigned char D.28355;
  guint8 * code.2633;
  guint8 * code.2634;
  unsigned char D.28358;
  guint8 * code.2635;
  guint8 * code.2636;
  unsigned char D.28361;
  guint8 * code.2637;
  guint8 * code.2638;
  unsigned char D.28364;
  guint8 * code.2639;
  guint8 * code.2640;
  unsigned char D.28367;
  guint8 * code.2641;
  guint8 * code.2642;
  unsigned char D.28371;
  guint8 * code.2643;
  guint8 * code.2644;
  unsigned char D.28374;
  guint8 * code.2645;
  guint8 * code.2646;
  unsigned char D.28377;
  guint8 * code.2647;
  guint8 * code.2648;
  unsigned char D.28380;
  guint8 * code.2649;
  guint8 * code.2650;
  unsigned char D.28385;
  guint8 * code.2651;
  guint8 * code.2652;
  guint8 * code.2653;
  guint8 * code.2654;
  guint8 * D.28390;
  guint8 * code.2655;
  guint8 * code.2656;
  guint8 * code.2657;
  guint8 * code.2658;
  unsigned char D.28401;
  guint8 * code.2659;
  guint8 * code.2660;
  guint8 * code.2661;
  guint8 * code.2662;
  guint8 * code.2663;
  guint8 * code.2664;
  guint8 * code.2665;
  guint8 * code.2666;
  unsigned char D.28412;
  guint8 * code.2667;
  guint8 * code.2668;
  unsigned char D.28415;
  guint8 * code.2669;
  guint8 * code.2670;
  unsigned char D.28418;
  guint8 * code.2671;
  guint8 * code.2672;
  unsigned char D.28421;
  guint8 * code.2673;
  guint8 * code.2674;
  guint8 * code.2675;
  guint8 * code.2676;
  guint8 * code.2677;
  guint8 * code.2678;
  guint8 * code.2679;
  guint8 * code.2680;
  guint8 * code.2681;
  guint8 * code.2682;
  guint8 * code.2683;
  guint8 * code.2684;
  guint8 * code.2685;
  guint8 * code.2686;
  unsigned char D.28445;
  guint8 * code.2687;
  guint8 * code.2688;
  unsigned char D.28448;
  guint8 * code.2689;
  guint8 * code.2690;
  unsigned char D.28451;
  guint8 * code.2691;
  guint8 * code.2692;
  unsigned char D.28454;
  guint8 * code.2693;
  guint8 * code.2694;
  guint8 * code.2695;
  guint8 * code.2696;
  guint8 * code.2697;
  guint8 * code.2698;
  guint8 * code.2699;
  guint8 * code.2700;
  unsigned char D.28468;
  guint8 * code.2701;
  guint8 * code.2702;
  unsigned char D.28471;
  guint8 * code.2703;
  guint8 * code.2704;
  unsigned char D.28474;
  guint8 * code.2705;
  guint8 * code.2706;
  unsigned char D.28477;
  unsigned char iftmp.2707;
  guint8 * code.2708;
  guint8 * code.2709;
  unsigned char D.28487;
  guint8 * code.2710;
  guint8 * code.2711;
  guint8 * code.2712;
  guint8 * code.2713;
  unsigned char D.28494;
  guint8 * code.2714;
  guint8 * code.2715;
  unsigned char D.28497;
  guint8 * code.2716;
  guint8 * code.2717;
  unsigned char D.28500;
  guint8 * code.2718;
  guint8 * code.2719;
  unsigned char D.28503;
  guint8 * code.2720;
  guint8 * code.2721;
  unsigned char D.28506;
  guint8 * code.2722;
  guint8 * code.2723;
  unsigned char D.28509;
  guint8 * code.2724;
  guint8 * code.2725;
  unsigned char D.28512;
  guint8 * code.2726;
  guint8 * code.2727;
  unsigned char D.28515;
  guint8 * code.2728;
  guint8 * code.2729;
  unsigned char D.28519;
  guint8 * code.2730;
  guint8 * code.2731;
  unsigned char D.28522;
  guint8 * code.2732;
  guint8 * code.2733;
  unsigned char D.28525;
  guint8 * code.2734;
  guint8 * code.2735;
  unsigned char D.28528;
  guint8 * code.2736;
  guint8 * code.2737;
  unsigned char D.28533;
  guint8 * code.2738;
  guint8 * code.2739;
  guint8 * code.2740;
  guint8 * code.2741;
  guint8 * code.2742;
  guint8 * code.2743;
  guint8 * code.2744;
  guint8 * code.2745;
  unsigned char D.28546;
  guint8 * code.2746;
  guint8 * code.2747;
  guint8 * code.2748;
  guint8 * code.2749;
  guint8 * code.2750;
  guint8 * code.2751;
  guint8 * code.2752;
  guint8 * code.2753;
  unsigned char D.28559;
  guint8 * code.2754;
  guint8 * code.2755;
  guint8 * code.2756;
  guint8 * code.2757;
  guint8 * code.2758;
  guint8 * code.2759;
  unsigned char D.28571;
  guint8 * code.2760;
  guint8 * code.2761;
  guint8 * code.2762;
  guint8 * code.2763;
  unsigned char D.28576;
  guint8 * code.2764;
  guint8 * code.2765;
  unsigned char D.28579;
  guint8 * code.2766;
  guint8 * code.2767;
  unsigned char D.28582;
  guint8 * code.2768;
  guint8 * code.2769;
  unsigned char D.28585;
  guint8 * code.2770;
  guint8 * code.2771;
  unsigned char D.28591;
  guint8 * code.2772;
  guint8 * code.2773;
  guint8 * code.2774;
  guint8 * code.2775;
  guint8 * code.2776;
  guint8 * code.2777;
  unsigned char D.28598;
  guint8 * code.2778;
  guint8 * code.2779;
  unsigned char D.28601;
  guint8 * code.2780;
  guint8 * code.2781;
  unsigned char D.28604;
  guint8 * code.2782;
  guint8 * code.2783;
  unsigned char D.28607;
  guint8 * code.2784;
  guint8 * code.2785;
  guint8 * code.2786;
  guint8 * code.2787;
  unsigned char D.28614;
  guint8 * code.2788;
  guint8 * code.2789;
  guint8 * code.2790;
  guint8 * code.2791;
  guint8 * code.2792;
  guint8 * code.2793;
  guint8 * code.2794;
  guint8 * code.2795;
  guint8 * code.2796;
  guint8 * code.2797;
  guint8 * code.2798;
  guint8 * code.2799;
  guint8 * code.2800;
  guint8 * code.2801;
  guint8 * code.2802;
  guint8 * code.2803;
  guint8 * code.2804;
  guint8 * code.2805;
  unsigned char D.28641;
  guint8 * code.2806;
  guint8 * code.2807;
  unsigned char D.28644;
  guint8 * code.2808;
  guint8 * code.2809;
  unsigned char D.28647;
  guint8 * code.2810;
  guint8 * code.2811;
  unsigned char D.28650;
  guint8 * code.2812;
  guint8 * code.2813;
  guint8 * code.2814;
  guint8 * code.2815;
  guint8 * code.2816;
  guint8 * code.2817;
  guint8 * code.2818;
  guint8 * code.2819;
  unsigned char D.28664;
  guint8 * code.2820;
  guint8 * code.2821;
  unsigned char D.28667;
  guint8 * code.2822;
  guint8 * code.2823;
  unsigned char D.28670;
  guint8 * code.2824;
  guint8 * code.2825;
  unsigned char D.28673;
  guint8 * code.2826;
  guint8 * code.2827;
  unsigned char D.28680;
  guint8 * code.2828;
  guint8 * code.2829;
  guint8 * code.2830;
  guint8 * code.2831;
  guint8 * code.2832;
  guint8 * code.2833;
  unsigned char D.28692;
  guint8 * code.2834;
  guint8 * code.2835;
  guint8 * code.2836;
  guint8 * code.2837;
  unsigned char D.28697;
  guint8 * code.2838;
  guint8 * code.2839;
  unsigned char D.28700;
  guint8 * code.2840;
  guint8 * code.2841;
  unsigned char D.28703;
  guint8 * code.2842;
  guint8 * code.2843;
  unsigned char D.28706;
  guint8 * code.2844;
  guint8 * code.2845;
  unsigned char D.28712;
  guint8 * code.2846;
  guint8 * code.2847;
  guint8 * code.2848;
  guint8 * code.2849;
  guint8 * code.2850;
  guint8 * code.2851;
  unsigned char D.28719;
  guint8 * code.2852;
  guint8 * code.2853;
  unsigned char D.28722;
  guint8 * code.2854;
  guint8 * code.2855;
  unsigned char D.28725;
  guint8 * code.2856;
  guint8 * code.2857;
  unsigned char D.28728;
  guint8 * code.2858;
  guint8 * code.2859;
  unsigned char D.28733;
  guint8 * code.2860;
  guint8 * code.2861;
  guint8 * code.2862;
  guint8 * code.2863;
  unsigned char D.28740;
  guint8 * code.2864;
  guint8 * code.2865;
  guint8 * code.2866;
  guint8 * code.2867;
  unsigned char D.28747;
  guint8 * code.2868;
  guint8 * code.2869;
  guint8 * code.2870;
  guint8 * code.2871;
  _Bool D.28752;
  long int D.28753;
  long int D.28754;
  unsigned int D.28759;
  struct MonoTrampInfo * D.28760;
  void * D.28761;
  guint8 * code;
  guint8 * start;
  guint8 * br[1];
  void * throw_trampoline;
  struct MonoJumpInfo * ji;
  struct GSList * unwind_ops;
  const guint kMaxCodeSize;
  static const char __PRETTY_FUNCTION__[38] = "mono_arch_get_throw_pending_exception";

  try
    {
      ji = 0B;
      unwind_ops = 0B;
      kMaxCodeSize = 128;
      kMaxCodeSize.2097 = (int) kMaxCodeSize;
      code.2098 = mono_global_codeman_reserve (kMaxCodeSize.2097);
      code = code.2098;
      code.2099 = code;
      start = code.2099;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.27450>; else goto <D.27451>;
        <D.27450>:
        code.2099 = code;
        code.2100 = code.2099;
        code.2101 = code.2100 + 1;
        code = code.2101;
        D.27454 = _amd64_rex_bits | 64;
        *code.2100 = D.27454;
        <D.27451>:
      }
      code.2099 = code;
      code.2102 = code.2099;
      code.2103 = code.2102 + 1;
      code = code.2103;
      *code.2102 = 80;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.27457>; else goto <D.27458>;
        <D.27457>:
        code.2099 = code;
        code.2104 = code.2099;
        code.2105 = code.2104 + 1;
        code = code.2105;
        D.27461 = _amd64_rex_bits | 64;
        *code.2104 = D.27461;
        <D.27458>:
      }
      code.2099 = code;
      code.2106 = code.2099;
      code.2107 = code.2106 + 1;
      code = code.2107;
      *code.2106 = 82;
      if (1 != 0) goto <D.27464>; else goto <D.27465>;
      <D.27464>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27466>; else goto <D.27467>;
        <D.27466>:
        code.2099 = code;
        code.2108 = code.2099;
        code.2109 = code.2108 + 1;
        code = code.2109;
        D.27470 = _amd64_rex_bits | 64;
        *code.2108 = D.27470;
        <D.27467>:
      }
      code.2099 = code;
      code.2110 = code.2099;
      code.2111 = code.2110 + 1;
      code = code.2111;
      *code.2110 = 131;
      code.2099 = code;
      code.2112 = code.2099;
      code.2113 = code.2112 + 1;
      code = code.2113;
      *code.2112 = 236;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27476>;
      <D.27465>:
      if (0 != 0) goto <D.27477>; else goto <D.27478>;
      <D.27477>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27479>; else goto <D.27480>;
        <D.27479>:
        code.2099 = code;
        code.2115 = code.2099;
        code.2116 = code.2115 + 1;
        code = code.2116;
        D.27483 = _amd64_rex_bits | 64;
        *code.2115 = D.27483;
        <D.27480>:
      }
      code.2099 = code;
      code.2117 = code.2099;
      code.2118 = code.2117 + 1;
      code = code.2118;
      *code.2117 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2119 = code.2099;
            code.2120 = code.2119 + 1;
            code = code.2120;
            D.27488 = imb.b[0];
            *code.2119 = D.27488;
            code.2099 = code;
            code.2121 = code.2099;
            code.2122 = code.2121 + 1;
            code = code.2122;
            D.27491 = imb.b[1];
            *code.2121 = D.27491;
            code.2099 = code;
            code.2123 = code.2099;
            code.2124 = code.2123 + 1;
            code = code.2124;
            D.27494 = imb.b[2];
            *code.2123 = D.27494;
            code.2099 = code;
            code.2125 = code.2099;
            code.2126 = code.2125 + 1;
            code = code.2126;
            D.27497 = imb.b[3];
            *code.2125 = D.27497;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27498>;
      <D.27478>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27499>; else goto <D.27500>;
        <D.27499>:
        code.2099 = code;
        code.2127 = code.2099;
        code.2128 = code.2127 + 1;
        code = code.2128;
        D.27503 = _amd64_rex_bits | 64;
        *code.2127 = D.27503;
        <D.27500>:
      }
      code.2099 = code;
      code.2129 = code.2099;
      code.2130 = code.2129 + 1;
      code = code.2130;
      *code.2129 = 129;
      code.2099 = code;
      code.2131 = code.2099;
      code.2132 = code.2131 + 1;
      code = code.2132;
      *code.2131 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2133 = code.2099;
            code.2134 = code.2133 + 1;
            code = code.2134;
            D.27510 = imb.b[0];
            *code.2133 = D.27510;
            code.2099 = code;
            code.2135 = code.2099;
            code.2136 = code.2135 + 1;
            code = code.2136;
            D.27513 = imb.b[1];
            *code.2135 = D.27513;
            code.2099 = code;
            code.2137 = code.2099;
            code.2138 = code.2137 + 1;
            code = code.2138;
            D.27516 = imb.b[2];
            *code.2137 = D.27516;
            code.2099 = code;
            code.2139 = code.2099;
            code.2140 = code.2139 + 1;
            code = code.2140;
            D.27519 = imb.b[3];
            *code.2139 = D.27519;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27498>:
      <D.27476>:
      code.2099 = code;
      code.2141 = code.2099;
      code.2142 = code.2141 + 1;
      code = code.2142;
      *code.2141 = 242;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.27522>; else goto <D.27523>;
        <D.27522>:
        code.2099 = code;
        code.2143 = code.2099;
        code.2144 = code.2143 + 1;
        code = code.2144;
        D.27526 = _amd64_rex_bits | 64;
        *code.2143 = D.27526;
        <D.27523>:
      }
      code.2099 = code;
      code.2145 = code.2099;
      code.2146 = code.2145 + 1;
      code = code.2146;
      *code.2145 = 15;
      code.2099 = code;
      code.2147 = code.2099;
      code.2148 = code.2147 + 1;
      code = code.2148;
      *code.2147 = 17;
      if (1 != 0) goto <D.27531>; else goto <D.27532>;
      <D.27531>:
      if (1 != 0) goto <D.27533>; else goto <D.27534>;
      <D.27533>:
      code.2099 = code;
      code.2149 = code.2099;
      code.2150 = code.2149 + 1;
      code = code.2150;
      *code.2149 = 4;
      code.2099 = code;
      code.2151 = code.2099;
      code.2152 = code.2151 + 1;
      code = code.2152;
      *code.2151 = 36;
      goto <D.27539>;
      <D.27534>:
      if (1 != 0) goto <D.27540>; else goto <D.27541>;
      <D.27540>:
      code.2099 = code;
      code.2153 = code.2099;
      code.2154 = code.2153 + 1;
      code = code.2154;
      *code.2153 = 68;
      code.2099 = code;
      code.2155 = code.2099;
      code.2156 = code.2155 + 1;
      code = code.2156;
      *code.2155 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27546>;
      <D.27541>:
      code.2099 = code;
      code.2157 = code.2099;
      code.2158 = code.2157 + 1;
      code = code.2158;
      *code.2157 = 132;
      code.2099 = code;
      code.2159 = code.2099;
      code.2160 = code.2159 + 1;
      code = code.2160;
      *code.2159 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2161 = code.2099;
            code.2162 = code.2161 + 1;
            code = code.2162;
            D.27553 = imb.b[0];
            *code.2161 = D.27553;
            code.2099 = code;
            code.2163 = code.2099;
            code.2164 = code.2163 + 1;
            code = code.2164;
            D.27556 = imb.b[1];
            *code.2163 = D.27556;
            code.2099 = code;
            code.2165 = code.2099;
            code.2166 = code.2165 + 1;
            code = code.2166;
            D.27559 = imb.b[2];
            *code.2165 = D.27559;
            code.2099 = code;
            code.2167 = code.2099;
            code.2168 = code.2167 + 1;
            code = code.2168;
            D.27562 = imb.b[3];
            *code.2167 = D.27562;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27546>:
      <D.27539>:
      goto <D.23349>;
      <D.27532>:
      if (1 != 0) goto <D.27563>; else goto <D.27564>;
      <D.27563>:
      code.2099 = code;
      code.2169 = code.2099;
      code.2170 = code.2169 + 1;
      code = code.2170;
      *code.2169 = 4;
      goto <D.23349>;
      <D.27564>:
      if (1 != 0) goto <D.27567>; else goto <D.27568>;
      <D.27567>:
      code.2099 = code;
      code.2171 = code.2099;
      code.2172 = code.2171 + 1;
      code = code.2172;
      *code.2171 = 68;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27571>;
      <D.27568>:
      code.2099 = code;
      code.2173 = code.2099;
      code.2174 = code.2173 + 1;
      code = code.2174;
      *code.2173 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2175 = code.2099;
            code.2176 = code.2175 + 1;
            code = code.2176;
            D.27576 = imb.b[0];
            *code.2175 = D.27576;
            code.2099 = code;
            code.2177 = code.2099;
            code.2178 = code.2177 + 1;
            code = code.2178;
            D.27579 = imb.b[1];
            *code.2177 = D.27579;
            code.2099 = code;
            code.2179 = code.2099;
            code.2180 = code.2179 + 1;
            code = code.2180;
            D.27582 = imb.b[2];
            *code.2179 = D.27582;
            code.2099 = code;
            code.2181 = code.2099;
            code.2182 = code.2181 + 1;
            code = code.2182;
            D.27585 = imb.b[3];
            *code.2181 = D.27585;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27571>:
      <D.23349>:
      if (1 != 0) goto <D.27586>; else goto <D.27587>;
      <D.27586>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27588>; else goto <D.27589>;
        <D.27588>:
        code.2099 = code;
        code.2183 = code.2099;
        code.2184 = code.2183 + 1;
        code = code.2184;
        D.27592 = _amd64_rex_bits | 64;
        *code.2183 = D.27592;
        <D.27589>:
      }
      code.2099 = code;
      code.2185 = code.2099;
      code.2186 = code.2185 + 1;
      code = code.2186;
      *code.2185 = 131;
      code.2099 = code;
      code.2187 = code.2099;
      code.2188 = code.2187 + 1;
      code = code.2188;
      *code.2187 = 236;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27597>;
      <D.27587>:
      if (0 != 0) goto <D.27598>; else goto <D.27599>;
      <D.27598>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27600>; else goto <D.27601>;
        <D.27600>:
        code.2099 = code;
        code.2189 = code.2099;
        code.2190 = code.2189 + 1;
        code = code.2190;
        D.27604 = _amd64_rex_bits | 64;
        *code.2189 = D.27604;
        <D.27601>:
      }
      code.2099 = code;
      code.2191 = code.2099;
      code.2192 = code.2191 + 1;
      code = code.2192;
      *code.2191 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2193 = code.2099;
            code.2194 = code.2193 + 1;
            code = code.2194;
            D.27609 = imb.b[0];
            *code.2193 = D.27609;
            code.2099 = code;
            code.2195 = code.2099;
            code.2196 = code.2195 + 1;
            code = code.2196;
            D.27612 = imb.b[1];
            *code.2195 = D.27612;
            code.2099 = code;
            code.2197 = code.2099;
            code.2198 = code.2197 + 1;
            code = code.2198;
            D.27615 = imb.b[2];
            *code.2197 = D.27615;
            code.2099 = code;
            code.2199 = code.2099;
            code.2200 = code.2199 + 1;
            code = code.2200;
            D.27618 = imb.b[3];
            *code.2199 = D.27618;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27619>;
      <D.27599>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27620>; else goto <D.27621>;
        <D.27620>:
        code.2099 = code;
        code.2201 = code.2099;
        code.2202 = code.2201 + 1;
        code = code.2202;
        D.27624 = _amd64_rex_bits | 64;
        *code.2201 = D.27624;
        <D.27621>:
      }
      code.2099 = code;
      code.2203 = code.2099;
      code.2204 = code.2203 + 1;
      code = code.2204;
      *code.2203 = 129;
      code.2099 = code;
      code.2205 = code.2099;
      code.2206 = code.2205 + 1;
      code = code.2206;
      *code.2205 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2207 = code.2099;
            code.2208 = code.2207 + 1;
            code = code.2208;
            D.27631 = imb.b[0];
            *code.2207 = D.27631;
            code.2099 = code;
            code.2209 = code.2099;
            code.2210 = code.2209 + 1;
            code = code.2210;
            D.27634 = imb.b[1];
            *code.2209 = D.27634;
            code.2099 = code;
            code.2211 = code.2099;
            code.2212 = code.2211 + 1;
            code = code.2212;
            D.27637 = imb.b[2];
            *code.2211 = D.27637;
            code.2099 = code;
            code.2213 = code.2099;
            code.2214 = code.2213 + 1;
            code = code.2214;
            D.27640 = imb.b[3];
            *code.2213 = D.27640;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27619>:
      <D.27597>:
      if (aot != 0) goto <D.27641>; else goto <D.27642>;
      <D.27641>:
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.27647 = (int) D.27646;
      ji = mono_patch_info_list_prepend (ji, D.27647, 32, "mono_thread_get_and_clear_pending_exception");
      if (0 != 0) goto <D.27648>; else goto <D.27649>;
      <D.27648>:
      code.2099 = code;
      code.2218 = code.2099;
      code.2219 = code.2218 + 1;
      code = code.2219;
      *code.2218 = 102;
      <D.27649>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.27652>; else goto <D.27653>;
        <D.27652>:
        code.2099 = code;
        code.2220 = code.2099;
        code.2221 = code.2220 + 1;
        code = code.2221;
        D.27656 = _amd64_rex_bits | 64;
        *code.2220 = D.27656;
        <D.27653>:
      }
      switch (8) <default: <D.23362>, case 1: <D.23357>, case 2: <D.23359>, case 4: <D.23360>, case 8: <D.23361>>
      <D.23357>:
      code.2099 = code;
      code.2222 = code.2099;
      code.2223 = code.2222 + 1;
      code = code.2223;
      *code.2222 = 138;
      goto <D.23358>;
      <D.23359>:
      <D.23360>:
      <D.23361>:
      code.2099 = code;
      code.2224 = code.2099;
      code.2225 = code.2224 + 1;
      code = code.2225;
      *code.2224 = 139;
      goto <D.23358>;
      <D.23362>:
      __assert_fail ("0", "exceptions-amd64.c", 992, &__PRETTY_FUNCTION__);
      <D.23358>:
      if (1 != 0) goto <D.27661>; else goto <D.27662>;
      <D.27661>:
      code.2099 = code;
      code.2226 = code.2099;
      code.2227 = code.2226 + 1;
      code = code.2227;
      *code.2226 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2228 = code.2099;
            code.2229 = code.2228 + 1;
            code = code.2229;
            D.27667 = imb.b[0];
            *code.2228 = D.27667;
            code.2099 = code;
            code.2230 = code.2099;
            code.2231 = code.2230 + 1;
            code = code.2231;
            D.27670 = imb.b[1];
            *code.2230 = D.27670;
            code.2099 = code;
            code.2232 = code.2099;
            code.2233 = code.2232 + 1;
            code = code.2233;
            D.27673 = imb.b[2];
            *code.2232 = D.27673;
            code.2099 = code;
            code.2234 = code.2099;
            code.2235 = code.2234 + 1;
            code = code.2235;
            D.27676 = imb.b[3];
            *code.2234 = D.27676;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27677>;
      <D.27662>:
      if (0 != 0) goto <D.27678>; else goto <D.27679>;
      <D.27678>:
      if (1 != 0) goto <D.27680>; else goto <D.27681>;
      <D.27680>:
      code.2099 = code;
      code.2236 = code.2099;
      code.2237 = code.2236 + 1;
      code = code.2237;
      *code.2236 = 28;
      code.2099 = code;
      code.2238 = code.2099;
      code.2239 = code.2238 + 1;
      code = code.2239;
      *code.2238 = 36;
      goto <D.27686>;
      <D.27681>:
      if (1 != 0) goto <D.27687>; else goto <D.27688>;
      <D.27687>:
      code.2099 = code;
      code.2240 = code.2099;
      code.2241 = code.2240 + 1;
      code = code.2241;
      *code.2240 = 92;
      code.2099 = code;
      code.2242 = code.2099;
      code.2243 = code.2242 + 1;
      code = code.2243;
      *code.2242 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27693>;
      <D.27688>:
      code.2099 = code;
      code.2244 = code.2099;
      code.2245 = code.2244 + 1;
      code = code.2245;
      *code.2244 = 156;
      code.2099 = code;
      code.2246 = code.2099;
      code.2247 = code.2246 + 1;
      code = code.2247;
      *code.2246 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2248 = code.2099;
            code.2249 = code.2248 + 1;
            code = code.2249;
            D.27700 = imb.b[0];
            *code.2248 = D.27700;
            code.2099 = code;
            code.2250 = code.2099;
            code.2251 = code.2250 + 1;
            code = code.2251;
            D.27703 = imb.b[1];
            *code.2250 = D.27703;
            code.2099 = code;
            code.2252 = code.2099;
            code.2253 = code.2252 + 1;
            code = code.2253;
            D.27706 = imb.b[2];
            *code.2252 = D.27706;
            code.2099 = code;
            code.2254 = code.2099;
            code.2255 = code.2254 + 1;
            code = code.2255;
            D.27709 = imb.b[3];
            *code.2254 = D.27709;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27693>:
      <D.27686>:
      goto <D.23366>;
      <D.27679>:
      if (1 != 0) goto <D.27710>; else goto <D.27711>;
      <D.27710>:
      code.2099 = code;
      code.2256 = code.2099;
      code.2257 = code.2256 + 1;
      code = code.2257;
      *code.2256 = 24;
      goto <D.23366>;
      <D.27711>:
      if (1 != 0) goto <D.27714>; else goto <D.27715>;
      <D.27714>:
      code.2099 = code;
      code.2258 = code.2099;
      code.2259 = code.2258 + 1;
      code = code.2259;
      *code.2258 = 88;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27718>;
      <D.27715>:
      code.2099 = code;
      code.2260 = code.2099;
      code.2261 = code.2260 + 1;
      code = code.2261;
      *code.2260 = 152;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2262 = code.2099;
            code.2263 = code.2262 + 1;
            code = code.2263;
            D.27723 = imb.b[0];
            *code.2262 = D.27723;
            code.2099 = code;
            code.2264 = code.2099;
            code.2265 = code.2264 + 1;
            code = code.2265;
            D.27726 = imb.b[1];
            *code.2264 = D.27726;
            code.2099 = code;
            code.2266 = code.2099;
            code.2267 = code.2266 + 1;
            code = code.2267;
            D.27729 = imb.b[2];
            *code.2266 = D.27729;
            code.2099 = code;
            code.2268 = code.2099;
            code.2269 = code.2268 + 1;
            code = code.2269;
            D.27732 = imb.b[3];
            *code.2268 = D.27732;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27718>:
      <D.23366>:
      <D.27677>:
      goto <D.27733>;
      <D.27642>:
      {
        int _amd64_width_temp;

        mono_thread_get_and_clear_pending_exception.2270 = (long int) mono_thread_get_and_clear_pending_exception;
        D.27735 = (int) mono_thread_get_and_clear_pending_exception.2270;
        D.27736 = (long unsigned int) D.27735;
        mono_thread_get_and_clear_pending_exception.2271 = (long unsigned int) mono_thread_get_and_clear_pending_exception;
        D.27738 = D.27736 == mono_thread_get_and_clear_pending_exception.2271;
        _amd64_width_temp = (int) D.27738;
        {
          unsigned char _amd64_rex_bits;

          if (_amd64_width_temp == 0) goto <D.27740>; else goto <D.27741>;
          <D.27740>:
          iftmp.2272 = 9;
          goto <D.27742>;
          <D.27741>:
          iftmp.2272 = 1;
          <D.27742>:
          _amd64_rex_bits = iftmp.2272;
          if (_amd64_rex_bits != 0) goto <D.27743>; else goto <D.27744>;
          <D.27743>:
          code.2099 = code;
          code.2273 = code.2099;
          code.2274 = code.2273 + 1;
          code = code.2274;
          D.27747 = _amd64_rex_bits | 64;
          *code.2273 = D.27747;
          <D.27744>:
        }
        code.2099 = code;
        code.2275 = code.2099;
        code.2276 = code.2275 + 1;
        code = code.2276;
        *code.2275 = 187;
        if (_amd64_width_temp == 0) goto <D.27750>; else goto <D.27751>;
        <D.27750>:
        {
          union amd64_imm_buf imb;

          try
            {
              mono_thread_get_and_clear_pending_exception.2271 = (long unsigned int) mono_thread_get_and_clear_pending_exception;
              imb.val = mono_thread_get_and_clear_pending_exception.2271;
              code.2099 = code;
              code.2277 = code.2099;
              code.2278 = code.2277 + 1;
              code = code.2278;
              D.27754 = imb.b[0];
              *code.2277 = D.27754;
              code.2099 = code;
              code.2279 = code.2099;
              code.2280 = code.2279 + 1;
              code = code.2280;
              D.27757 = imb.b[1];
              *code.2279 = D.27757;
              code.2099 = code;
              code.2281 = code.2099;
              code.2282 = code.2281 + 1;
              code = code.2282;
              D.27760 = imb.b[2];
              *code.2281 = D.27760;
              code.2099 = code;
              code.2283 = code.2099;
              code.2284 = code.2283 + 1;
              code = code.2284;
              D.27763 = imb.b[3];
              *code.2283 = D.27763;
              code.2099 = code;
              code.2285 = code.2099;
              code.2286 = code.2285 + 1;
              code = code.2286;
              D.27766 = imb.b[4];
              *code.2285 = D.27766;
              code.2099 = code;
              code.2287 = code.2099;
              code.2288 = code.2287 + 1;
              code = code.2288;
              D.27769 = imb.b[5];
              *code.2287 = D.27769;
              code.2099 = code;
              code.2289 = code.2099;
              code.2290 = code.2289 + 1;
              code = code.2290;
              D.27772 = imb.b[6];
              *code.2289 = D.27772;
              code.2099 = code;
              code.2291 = code.2099;
              code.2292 = code.2291 + 1;
              code = code.2292;
              D.27775 = imb.b[7];
              *code.2291 = D.27775;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.27776>;
        <D.27751>:
        {
          union x86_imm_buf imb;

          try
            {
              mono_thread_get_and_clear_pending_exception.2270 = (long int) mono_thread_get_and_clear_pending_exception;
              D.27735 = (int) mono_thread_get_and_clear_pending_exception.2270;
              imb.val = D.27735;
              code.2099 = code;
              code.2293 = code.2099;
              code.2294 = code.2293 + 1;
              code = code.2294;
              D.27779 = imb.b[0];
              *code.2293 = D.27779;
              code.2099 = code;
              code.2295 = code.2099;
              code.2296 = code.2295 + 1;
              code = code.2296;
              D.27782 = imb.b[1];
              *code.2295 = D.27782;
              code.2099 = code;
              code.2297 = code.2099;
              code.2298 = code.2297 + 1;
              code = code.2298;
              D.27785 = imb.b[2];
              *code.2297 = D.27785;
              code.2099 = code;
              code.2299 = code.2099;
              code.2300 = code.2299 + 1;
              code = code.2300;
              D.27788 = imb.b[3];
              *code.2299 = D.27788;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.27776>:
      }
      <D.27733>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.27789>; else goto <D.27790>;
        <D.27789>:
        code.2099 = code;
        code.2301 = code.2099;
        code.2302 = code.2301 + 1;
        code = code.2302;
        D.27793 = _amd64_rex_bits | 64;
        *code.2301 = D.27793;
        <D.27790>:
      }
      code.2099 = code;
      code.2303 = code.2099;
      code.2304 = code.2303 + 1;
      code = code.2304;
      *code.2303 = 255;
      code.2099 = code;
      code.2305 = code.2099;
      code.2306 = code.2305 + 1;
      code = code.2306;
      *code.2305 = 211;
      if (1 != 0) goto <D.27798>; else goto <D.27799>;
      <D.27798>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27800>; else goto <D.27801>;
        <D.27800>:
        code.2099 = code;
        code.2307 = code.2099;
        code.2308 = code.2307 + 1;
        code = code.2308;
        D.27804 = _amd64_rex_bits | 64;
        *code.2307 = D.27804;
        <D.27801>:
      }
      code.2099 = code;
      code.2309 = code.2099;
      code.2310 = code.2309 + 1;
      code = code.2310;
      *code.2309 = 131;
      code.2099 = code;
      code.2311 = code.2099;
      code.2312 = code.2311 + 1;
      code = code.2312;
      *code.2311 = 248;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27809>;
      <D.27799>:
      if (1 != 0) goto <D.27810>; else goto <D.27811>;
      <D.27810>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27812>; else goto <D.27813>;
        <D.27812>:
        code.2099 = code;
        code.2313 = code.2099;
        code.2314 = code.2313 + 1;
        code = code.2314;
        D.27816 = _amd64_rex_bits | 64;
        *code.2313 = D.27816;
        <D.27813>:
      }
      code.2099 = code;
      code.2315 = code.2099;
      code.2316 = code.2315 + 1;
      code = code.2316;
      *code.2315 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2317 = code.2099;
            code.2318 = code.2317 + 1;
            code = code.2318;
            D.27821 = imb.b[0];
            *code.2317 = D.27821;
            code.2099 = code;
            code.2319 = code.2099;
            code.2320 = code.2319 + 1;
            code = code.2320;
            D.27824 = imb.b[1];
            *code.2319 = D.27824;
            code.2099 = code;
            code.2321 = code.2099;
            code.2322 = code.2321 + 1;
            code = code.2322;
            D.27827 = imb.b[2];
            *code.2321 = D.27827;
            code.2099 = code;
            code.2323 = code.2099;
            code.2324 = code.2323 + 1;
            code = code.2324;
            D.27830 = imb.b[3];
            *code.2323 = D.27830;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27831>;
      <D.27811>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27832>; else goto <D.27833>;
        <D.27832>:
        code.2099 = code;
        code.2325 = code.2099;
        code.2326 = code.2325 + 1;
        code = code.2326;
        D.27836 = _amd64_rex_bits | 64;
        *code.2325 = D.27836;
        <D.27833>:
      }
      code.2099 = code;
      code.2327 = code.2099;
      code.2328 = code.2327 + 1;
      code = code.2328;
      *code.2327 = 129;
      code.2099 = code;
      code.2329 = code.2099;
      code.2330 = code.2329 + 1;
      code = code.2330;
      *code.2329 = 248;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2331 = code.2099;
            code.2332 = code.2331 + 1;
            code = code.2332;
            D.27843 = imb.b[0];
            *code.2331 = D.27843;
            code.2099 = code;
            code.2333 = code.2099;
            code.2334 = code.2333 + 1;
            code = code.2334;
            D.27846 = imb.b[1];
            *code.2333 = D.27846;
            code.2099 = code;
            code.2335 = code.2099;
            code.2336 = code.2335 + 1;
            code = code.2336;
            D.27849 = imb.b[2];
            *code.2335 = D.27849;
            code.2099 = code;
            code.2337 = code.2099;
            code.2338 = code.2337 + 1;
            code = code.2338;
            D.27852 = imb.b[3];
            *code.2337 = D.27852;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27831>:
      <D.27809>:
      code.2099 = code;
      br[0] = code.2099;
      if (0 != 0) goto <D.27853>; else goto <D.27854>;
      <D.27853>:
      code.2099 = code;
      code.2339 = code.2099;
      code.2340 = code.2339 + 1;
      code = code.2340;
      D.27857 = 116;
      *code.2339 = D.27857;
      goto <D.27858>;
      <D.27854>:
      code.2099 = code;
      code.2341 = code.2099;
      code.2342 = code.2341 + 1;
      code = code.2342;
      D.27861 = 116;
      *code.2341 = D.27861;
      <D.27858>:
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.27862>; else goto <D.27863>;
        <D.27862>:
        code.2099 = code;
        code.2343 = code.2099;
        code.2344 = code.2343 + 1;
        code = code.2344;
        D.27866 = _amd64_rex_bits | 64;
        *code.2343 = D.27866;
        <D.27863>:
      }
      code.2099 = code;
      code.2345 = code.2099;
      code.2346 = code.2345 + 1;
      code = code.2346;
      *code.2345 = 80;
      if (1 != 0) goto <D.27869>; else goto <D.27870>;
      <D.27869>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27871>; else goto <D.27872>;
        <D.27871>:
        code.2099 = code;
        code.2347 = code.2099;
        code.2348 = code.2347 + 1;
        code = code.2348;
        D.27875 = _amd64_rex_bits | 64;
        *code.2347 = D.27875;
        <D.27872>:
      }
      code.2099 = code;
      code.2349 = code.2099;
      code.2350 = code.2349 + 1;
      code = code.2350;
      *code.2349 = 131;
      code.2099 = code;
      code.2351 = code.2099;
      code.2352 = code.2351 + 1;
      code = code.2352;
      *code.2351 = 236;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27880>;
      <D.27870>:
      if (0 != 0) goto <D.27881>; else goto <D.27882>;
      <D.27881>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27883>; else goto <D.27884>;
        <D.27883>:
        code.2099 = code;
        code.2353 = code.2099;
        code.2354 = code.2353 + 1;
        code = code.2354;
        D.27887 = _amd64_rex_bits | 64;
        *code.2353 = D.27887;
        <D.27884>:
      }
      code.2099 = code;
      code.2355 = code.2099;
      code.2356 = code.2355 + 1;
      code = code.2356;
      *code.2355 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2357 = code.2099;
            code.2358 = code.2357 + 1;
            code = code.2358;
            D.27892 = imb.b[0];
            *code.2357 = D.27892;
            code.2099 = code;
            code.2359 = code.2099;
            code.2360 = code.2359 + 1;
            code = code.2360;
            D.27895 = imb.b[1];
            *code.2359 = D.27895;
            code.2099 = code;
            code.2361 = code.2099;
            code.2362 = code.2361 + 1;
            code = code.2362;
            D.27898 = imb.b[2];
            *code.2361 = D.27898;
            code.2099 = code;
            code.2363 = code.2099;
            code.2364 = code.2363 + 1;
            code = code.2364;
            D.27901 = imb.b[3];
            *code.2363 = D.27901;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27902>;
      <D.27882>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.27903>; else goto <D.27904>;
        <D.27903>:
        code.2099 = code;
        code.2365 = code.2099;
        code.2366 = code.2365 + 1;
        code = code.2366;
        D.27907 = _amd64_rex_bits | 64;
        *code.2365 = D.27907;
        <D.27904>:
      }
      code.2099 = code;
      code.2367 = code.2099;
      code.2368 = code.2367 + 1;
      code = code.2368;
      *code.2367 = 129;
      code.2099 = code;
      code.2369 = code.2099;
      code.2370 = code.2369 + 1;
      code = code.2370;
      *code.2369 = 236;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2371 = code.2099;
            code.2372 = code.2371 + 1;
            code = code.2372;
            D.27914 = imb.b[0];
            *code.2371 = D.27914;
            code.2099 = code;
            code.2373 = code.2099;
            code.2374 = code.2373 + 1;
            code = code.2374;
            D.27917 = imb.b[1];
            *code.2373 = D.27917;
            code.2099 = code;
            code.2375 = code.2099;
            code.2376 = code.2375 + 1;
            code = code.2376;
            D.27920 = imb.b[2];
            *code.2375 = D.27920;
            code.2099 = code;
            code.2377 = code.2099;
            code.2378 = code.2377 + 1;
            code = code.2378;
            D.27923 = imb.b[3];
            *code.2377 = D.27923;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27902>:
      <D.27880>:
      if (aot != 0) goto <D.27924>; else goto <D.27925>;
      <D.27924>:
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.27647 = (int) D.27646;
      ji = mono_patch_info_list_prepend (ji, D.27647, 32, "mono_amd64_get_original_ip");
      if (0 != 0) goto <D.27926>; else goto <D.27927>;
      <D.27926>:
      code.2099 = code;
      code.2379 = code.2099;
      code.2380 = code.2379 + 1;
      code = code.2380;
      *code.2379 = 102;
      <D.27927>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.27930>; else goto <D.27931>;
        <D.27930>:
        code.2099 = code;
        code.2381 = code.2099;
        code.2382 = code.2381 + 1;
        code = code.2382;
        D.27934 = _amd64_rex_bits | 64;
        *code.2381 = D.27934;
        <D.27931>:
      }
      switch (8) <default: <D.23390>, case 1: <D.23385>, case 2: <D.23387>, case 4: <D.23388>, case 8: <D.23389>>
      <D.23385>:
      code.2099 = code;
      code.2383 = code.2099;
      code.2384 = code.2383 + 1;
      code = code.2384;
      *code.2383 = 138;
      goto <D.23386>;
      <D.23387>:
      <D.23388>:
      <D.23389>:
      code.2099 = code;
      code.2385 = code.2099;
      code.2386 = code.2385 + 1;
      code = code.2386;
      *code.2385 = 139;
      goto <D.23386>;
      <D.23390>:
      __assert_fail ("0", "exceptions-amd64.c", 1012, &__PRETTY_FUNCTION__);
      <D.23386>:
      if (1 != 0) goto <D.27939>; else goto <D.27940>;
      <D.27939>:
      code.2099 = code;
      code.2387 = code.2099;
      code.2388 = code.2387 + 1;
      code = code.2388;
      *code.2387 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2389 = code.2099;
            code.2390 = code.2389 + 1;
            code = code.2390;
            D.27945 = imb.b[0];
            *code.2389 = D.27945;
            code.2099 = code;
            code.2391 = code.2099;
            code.2392 = code.2391 + 1;
            code = code.2392;
            D.27948 = imb.b[1];
            *code.2391 = D.27948;
            code.2099 = code;
            code.2393 = code.2099;
            code.2394 = code.2393 + 1;
            code = code.2394;
            D.27951 = imb.b[2];
            *code.2393 = D.27951;
            code.2099 = code;
            code.2395 = code.2099;
            code.2396 = code.2395 + 1;
            code = code.2396;
            D.27954 = imb.b[3];
            *code.2395 = D.27954;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.27955>;
      <D.27940>:
      if (0 != 0) goto <D.27956>; else goto <D.27957>;
      <D.27956>:
      if (1 != 0) goto <D.27958>; else goto <D.27959>;
      <D.27958>:
      code.2099 = code;
      code.2397 = code.2099;
      code.2398 = code.2397 + 1;
      code = code.2398;
      *code.2397 = 28;
      code.2099 = code;
      code.2399 = code.2099;
      code.2400 = code.2399 + 1;
      code = code.2400;
      *code.2399 = 36;
      goto <D.27964>;
      <D.27959>:
      if (1 != 0) goto <D.27965>; else goto <D.27966>;
      <D.27965>:
      code.2099 = code;
      code.2401 = code.2099;
      code.2402 = code.2401 + 1;
      code = code.2402;
      *code.2401 = 92;
      code.2099 = code;
      code.2403 = code.2099;
      code.2404 = code.2403 + 1;
      code = code.2404;
      *code.2403 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27971>;
      <D.27966>:
      code.2099 = code;
      code.2405 = code.2099;
      code.2406 = code.2405 + 1;
      code = code.2406;
      *code.2405 = 156;
      code.2099 = code;
      code.2407 = code.2099;
      code.2408 = code.2407 + 1;
      code = code.2408;
      *code.2407 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2409 = code.2099;
            code.2410 = code.2409 + 1;
            code = code.2410;
            D.27978 = imb.b[0];
            *code.2409 = D.27978;
            code.2099 = code;
            code.2411 = code.2099;
            code.2412 = code.2411 + 1;
            code = code.2412;
            D.27981 = imb.b[1];
            *code.2411 = D.27981;
            code.2099 = code;
            code.2413 = code.2099;
            code.2414 = code.2413 + 1;
            code = code.2414;
            D.27984 = imb.b[2];
            *code.2413 = D.27984;
            code.2099 = code;
            code.2415 = code.2099;
            code.2416 = code.2415 + 1;
            code = code.2416;
            D.27987 = imb.b[3];
            *code.2415 = D.27987;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27971>:
      <D.27964>:
      goto <D.23393>;
      <D.27957>:
      if (1 != 0) goto <D.27988>; else goto <D.27989>;
      <D.27988>:
      code.2099 = code;
      code.2417 = code.2099;
      code.2418 = code.2417 + 1;
      code = code.2418;
      *code.2417 = 24;
      goto <D.23393>;
      <D.27989>:
      if (1 != 0) goto <D.27992>; else goto <D.27993>;
      <D.27992>:
      code.2099 = code;
      code.2419 = code.2099;
      code.2420 = code.2419 + 1;
      code = code.2420;
      *code.2419 = 88;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.27996>;
      <D.27993>:
      code.2099 = code;
      code.2421 = code.2099;
      code.2422 = code.2421 + 1;
      code = code.2422;
      *code.2421 = 152;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2423 = code.2099;
            code.2424 = code.2423 + 1;
            code = code.2424;
            D.28001 = imb.b[0];
            *code.2423 = D.28001;
            code.2099 = code;
            code.2425 = code.2099;
            code.2426 = code.2425 + 1;
            code = code.2426;
            D.28004 = imb.b[1];
            *code.2425 = D.28004;
            code.2099 = code;
            code.2427 = code.2099;
            code.2428 = code.2427 + 1;
            code = code.2428;
            D.28007 = imb.b[2];
            *code.2427 = D.28007;
            code.2099 = code;
            code.2429 = code.2099;
            code.2430 = code.2429 + 1;
            code = code.2430;
            D.28010 = imb.b[3];
            *code.2429 = D.28010;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.27996>:
      <D.23393>:
      <D.27955>:
      goto <D.28011>;
      <D.27925>:
      {
        int _amd64_width_temp;

        mono_amd64_get_original_ip.2431 = (long int) mono_amd64_get_original_ip;
        D.28013 = (int) mono_amd64_get_original_ip.2431;
        D.28014 = (long unsigned int) D.28013;
        mono_amd64_get_original_ip.2432 = (long unsigned int) mono_amd64_get_original_ip;
        D.28016 = D.28014 == mono_amd64_get_original_ip.2432;
        _amd64_width_temp = (int) D.28016;
        {
          unsigned char _amd64_rex_bits;

          if (_amd64_width_temp == 0) goto <D.28018>; else goto <D.28019>;
          <D.28018>:
          iftmp.2433 = 9;
          goto <D.28020>;
          <D.28019>:
          iftmp.2433 = 1;
          <D.28020>:
          _amd64_rex_bits = iftmp.2433;
          if (_amd64_rex_bits != 0) goto <D.28021>; else goto <D.28022>;
          <D.28021>:
          code.2099 = code;
          code.2434 = code.2099;
          code.2435 = code.2434 + 1;
          code = code.2435;
          D.28025 = _amd64_rex_bits | 64;
          *code.2434 = D.28025;
          <D.28022>:
        }
        code.2099 = code;
        code.2436 = code.2099;
        code.2437 = code.2436 + 1;
        code = code.2437;
        *code.2436 = 187;
        if (_amd64_width_temp == 0) goto <D.28028>; else goto <D.28029>;
        <D.28028>:
        {
          union amd64_imm_buf imb;

          try
            {
              mono_amd64_get_original_ip.2432 = (long unsigned int) mono_amd64_get_original_ip;
              imb.val = mono_amd64_get_original_ip.2432;
              code.2099 = code;
              code.2438 = code.2099;
              code.2439 = code.2438 + 1;
              code = code.2439;
              D.28032 = imb.b[0];
              *code.2438 = D.28032;
              code.2099 = code;
              code.2440 = code.2099;
              code.2441 = code.2440 + 1;
              code = code.2441;
              D.28035 = imb.b[1];
              *code.2440 = D.28035;
              code.2099 = code;
              code.2442 = code.2099;
              code.2443 = code.2442 + 1;
              code = code.2443;
              D.28038 = imb.b[2];
              *code.2442 = D.28038;
              code.2099 = code;
              code.2444 = code.2099;
              code.2445 = code.2444 + 1;
              code = code.2445;
              D.28041 = imb.b[3];
              *code.2444 = D.28041;
              code.2099 = code;
              code.2446 = code.2099;
              code.2447 = code.2446 + 1;
              code = code.2447;
              D.28044 = imb.b[4];
              *code.2446 = D.28044;
              code.2099 = code;
              code.2448 = code.2099;
              code.2449 = code.2448 + 1;
              code = code.2449;
              D.28047 = imb.b[5];
              *code.2448 = D.28047;
              code.2099 = code;
              code.2450 = code.2099;
              code.2451 = code.2450 + 1;
              code = code.2451;
              D.28050 = imb.b[6];
              *code.2450 = D.28050;
              code.2099 = code;
              code.2452 = code.2099;
              code.2453 = code.2452 + 1;
              code = code.2453;
              D.28053 = imb.b[7];
              *code.2452 = D.28053;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28054>;
        <D.28029>:
        {
          union x86_imm_buf imb;

          try
            {
              mono_amd64_get_original_ip.2431 = (long int) mono_amd64_get_original_ip;
              D.28013 = (int) mono_amd64_get_original_ip.2431;
              imb.val = D.28013;
              code.2099 = code;
              code.2454 = code.2099;
              code.2455 = code.2454 + 1;
              code = code.2455;
              D.28057 = imb.b[0];
              *code.2454 = D.28057;
              code.2099 = code;
              code.2456 = code.2099;
              code.2457 = code.2456 + 1;
              code = code.2457;
              D.28060 = imb.b[1];
              *code.2456 = D.28060;
              code.2099 = code;
              code.2458 = code.2099;
              code.2459 = code.2458 + 1;
              code = code.2459;
              D.28063 = imb.b[2];
              *code.2458 = D.28063;
              code.2099 = code;
              code.2460 = code.2099;
              code.2461 = code.2460 + 1;
              code = code.2461;
              D.28066 = imb.b[3];
              *code.2460 = D.28066;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28054>:
      }
      <D.28011>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.28067>; else goto <D.28068>;
        <D.28067>:
        code.2099 = code;
        code.2462 = code.2099;
        code.2463 = code.2462 + 1;
        code = code.2463;
        D.28071 = _amd64_rex_bits | 64;
        *code.2462 = D.28071;
        <D.28068>:
      }
      code.2099 = code;
      code.2464 = code.2099;
      code.2465 = code.2464 + 1;
      code = code.2465;
      *code.2464 = 255;
      code.2099 = code;
      code.2466 = code.2099;
      code.2467 = code.2466 + 1;
      code = code.2467;
      *code.2466 = 211;
      if (0 != 0) goto <D.28076>; else goto <D.28077>;
      <D.28076>:
      code.2099 = code;
      code.2468 = code.2099;
      code.2469 = code.2468 + 1;
      code = code.2469;
      *code.2468 = 102;
      <D.28077>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.28080>; else goto <D.28081>;
        <D.28080>:
        code.2099 = code;
        code.2470 = code.2099;
        code.2471 = code.2470 + 1;
        code = code.2471;
        D.28084 = _amd64_rex_bits | 64;
        *code.2470 = D.28084;
        <D.28081>:
      }
      switch (8) <default: <D.23406>, case 1: <D.23401>, case 2: <D.23403>, case 4: <D.23404>, case 8: <D.23405>>
      <D.23401>:
      code.2099 = code;
      code.2472 = code.2099;
      code.2473 = code.2472 + 1;
      code = code.2473;
      *code.2472 = 138;
      goto <D.23402>;
      <D.23403>:
      <D.23404>:
      <D.23405>:
      code.2099 = code;
      code.2474 = code.2099;
      code.2475 = code.2474 + 1;
      code = code.2475;
      *code.2474 = 139;
      goto <D.23402>;
      <D.23406>:
      __assert_fail ("0", "exceptions-amd64.c", 1019, &__PRETTY_FUNCTION__);
      <D.23402>:
      if (0 != 0) goto <D.28089>; else goto <D.28090>;
      <D.28089>:
      code.2099 = code;
      code.2476 = code.2099;
      code.2477 = code.2476 + 1;
      code = code.2477;
      *code.2476 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2478 = code.2099;
            code.2479 = code.2478 + 1;
            code = code.2479;
            D.28095 = imb.b[0];
            *code.2478 = D.28095;
            code.2099 = code;
            code.2480 = code.2099;
            code.2481 = code.2480 + 1;
            code = code.2481;
            D.28098 = imb.b[1];
            *code.2480 = D.28098;
            code.2099 = code;
            code.2482 = code.2099;
            code.2483 = code.2482 + 1;
            code = code.2483;
            D.28101 = imb.b[2];
            *code.2482 = D.28101;
            code.2099 = code;
            code.2484 = code.2099;
            code.2485 = code.2484 + 1;
            code = code.2485;
            D.28104 = imb.b[3];
            *code.2484 = D.28104;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28105>;
      <D.28090>:
      if (1 != 0) goto <D.28106>; else goto <D.28107>;
      <D.28106>:
      if (0 != 0) goto <D.28108>; else goto <D.28109>;
      <D.28108>:
      code.2099 = code;
      code.2486 = code.2099;
      code.2487 = code.2486 + 1;
      code = code.2487;
      *code.2486 = 28;
      code.2099 = code;
      code.2488 = code.2099;
      code.2489 = code.2488 + 1;
      code = code.2489;
      *code.2488 = 36;
      goto <D.28114>;
      <D.28109>:
      if (1 != 0) goto <D.28115>; else goto <D.28116>;
      <D.28115>:
      code.2099 = code;
      code.2490 = code.2099;
      code.2491 = code.2490 + 1;
      code = code.2491;
      *code.2490 = 92;
      code.2099 = code;
      code.2492 = code.2099;
      code.2493 = code.2492 + 1;
      code = code.2493;
      *code.2492 = 36;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28121>;
      <D.28116>:
      code.2099 = code;
      code.2494 = code.2099;
      code.2495 = code.2494 + 1;
      code = code.2495;
      *code.2494 = 156;
      code.2099 = code;
      code.2496 = code.2099;
      code.2497 = code.2496 + 1;
      code = code.2497;
      *code.2496 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2498 = code.2099;
            code.2499 = code.2498 + 1;
            code = code.2499;
            D.28128 = imb.b[0];
            *code.2498 = D.28128;
            code.2099 = code;
            code.2500 = code.2099;
            code.2501 = code.2500 + 1;
            code = code.2501;
            D.28131 = imb.b[1];
            *code.2500 = D.28131;
            code.2099 = code;
            code.2502 = code.2099;
            code.2503 = code.2502 + 1;
            code = code.2503;
            D.28134 = imb.b[2];
            *code.2502 = D.28134;
            code.2099 = code;
            code.2504 = code.2099;
            code.2505 = code.2504 + 1;
            code = code.2505;
            D.28137 = imb.b[3];
            *code.2504 = D.28137;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28121>:
      <D.28114>:
      goto <D.23409>;
      <D.28107>:
      if (0 != 0) goto <D.28138>; else goto <D.28139>;
      <D.28138>:
      code.2099 = code;
      code.2506 = code.2099;
      code.2507 = code.2506 + 1;
      code = code.2507;
      *code.2506 = 28;
      goto <D.23409>;
      <D.28139>:
      if (1 != 0) goto <D.28142>; else goto <D.28143>;
      <D.28142>:
      code.2099 = code;
      code.2508 = code.2099;
      code.2509 = code.2508 + 1;
      code = code.2509;
      *code.2508 = 92;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28146>;
      <D.28143>:
      code.2099 = code;
      code.2510 = code.2099;
      code.2511 = code.2510 + 1;
      code = code.2511;
      *code.2510 = 156;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2512 = code.2099;
            code.2513 = code.2512 + 1;
            code = code.2513;
            D.28151 = imb.b[0];
            *code.2512 = D.28151;
            code.2099 = code;
            code.2514 = code.2099;
            code.2515 = code.2514 + 1;
            code = code.2515;
            D.28154 = imb.b[1];
            *code.2514 = D.28154;
            code.2099 = code;
            code.2516 = code.2099;
            code.2517 = code.2516 + 1;
            code = code.2517;
            D.28157 = imb.b[2];
            *code.2516 = D.28157;
            code.2099 = code;
            code.2518 = code.2099;
            code.2519 = code.2518 + 1;
            code = code.2519;
            D.28160 = imb.b[3];
            *code.2518 = D.28160;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28146>:
      <D.23409>:
      <D.28105>:
      if (1 != 0) goto <D.28161>; else goto <D.28162>;
      <D.28161>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28163>; else goto <D.28164>;
        <D.28163>:
        code.2099 = code;
        code.2520 = code.2099;
        code.2521 = code.2520 + 1;
        code = code.2521;
        D.28167 = _amd64_rex_bits | 64;
        *code.2520 = D.28167;
        <D.28164>:
      }
      code.2099 = code;
      code.2522 = code.2099;
      code.2523 = code.2522 + 1;
      code = code.2523;
      *code.2522 = 131;
      code.2099 = code;
      code.2524 = code.2099;
      code.2525 = code.2524 + 1;
      code = code.2525;
      *code.2524 = 196;
      code.2099 = code;
      *code.2099 = 48;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28172>;
      <D.28162>:
      if (0 != 0) goto <D.28173>; else goto <D.28174>;
      <D.28173>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28175>; else goto <D.28176>;
        <D.28175>:
        code.2099 = code;
        code.2526 = code.2099;
        code.2527 = code.2526 + 1;
        code = code.2527;
        D.28179 = _amd64_rex_bits | 64;
        *code.2526 = D.28179;
        <D.28176>:
      }
      code.2099 = code;
      code.2528 = code.2099;
      code.2529 = code.2528 + 1;
      code = code.2529;
      *code.2528 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.2099 = code;
            code.2530 = code.2099;
            code.2531 = code.2530 + 1;
            code = code.2531;
            D.28184 = imb.b[0];
            *code.2530 = D.28184;
            code.2099 = code;
            code.2532 = code.2099;
            code.2533 = code.2532 + 1;
            code = code.2533;
            D.28187 = imb.b[1];
            *code.2532 = D.28187;
            code.2099 = code;
            code.2534 = code.2099;
            code.2535 = code.2534 + 1;
            code = code.2535;
            D.28190 = imb.b[2];
            *code.2534 = D.28190;
            code.2099 = code;
            code.2536 = code.2099;
            code.2537 = code.2536 + 1;
            code = code.2537;
            D.28193 = imb.b[3];
            *code.2536 = D.28193;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28194>;
      <D.28174>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28195>; else goto <D.28196>;
        <D.28195>:
        code.2099 = code;
        code.2538 = code.2099;
        code.2539 = code.2538 + 1;
        code = code.2539;
        D.28199 = _amd64_rex_bits | 64;
        *code.2538 = D.28199;
        <D.28196>:
      }
      code.2099 = code;
      code.2540 = code.2099;
      code.2541 = code.2540 + 1;
      code = code.2541;
      *code.2540 = 129;
      code.2099 = code;
      code.2542 = code.2099;
      code.2543 = code.2542 + 1;
      code = code.2543;
      *code.2542 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.2099 = code;
            code.2544 = code.2099;
            code.2545 = code.2544 + 1;
            code = code.2545;
            D.28206 = imb.b[0];
            *code.2544 = D.28206;
            code.2099 = code;
            code.2546 = code.2099;
            code.2547 = code.2546 + 1;
            code = code.2547;
            D.28209 = imb.b[1];
            *code.2546 = D.28209;
            code.2099 = code;
            code.2548 = code.2099;
            code.2549 = code.2548 + 1;
            code = code.2549;
            D.28212 = imb.b[2];
            *code.2548 = D.28212;
            code.2099 = code;
            code.2550 = code.2099;
            code.2551 = code.2550 + 1;
            code = code.2551;
            D.28215 = imb.b[3];
            *code.2550 = D.28215;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28194>:
      <D.28172>:
      if (0 != 0) goto <D.28216>; else goto <D.28217>;
      <D.28216>:
      code.2099 = code;
      code.2552 = code.2099;
      code.2553 = code.2552 + 1;
      code = code.2553;
      *code.2552 = 102;
      <D.28217>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 9;
        if (_amd64_rex_bits != 0) goto <D.28220>; else goto <D.28221>;
        <D.28220>:
        code.2099 = code;
        code.2554 = code.2099;
        code.2555 = code.2554 + 1;
        code = code.2555;
        D.28224 = _amd64_rex_bits | 64;
        *code.2554 = D.28224;
        <D.28221>:
      }
      switch (8) <default: <D.23422>, case 1: <D.23417>, case 2: <D.23419>, case 4: <D.23420>, case 8: <D.23421>>
      <D.23417>:
      code.2099 = code;
      code.2556 = code.2099;
      code.2557 = code.2556 + 1;
      code = code.2557;
      *code.2556 = 138;
      goto <D.23418>;
      <D.23419>:
      <D.23420>:
      <D.23421>:
      code.2099 = code;
      code.2558 = code.2099;
      code.2559 = code.2558 + 1;
      code = code.2559;
      *code.2558 = 139;
      goto <D.23418>;
      <D.23422>:
      __assert_fail ("0", "exceptions-amd64.c", 1026, &__PRETTY_FUNCTION__);
      <D.23418>:
      code.2099 = code;
      code.2560 = code.2099;
      code.2561 = code.2560 + 1;
      code = code.2561;
      *code.2560 = 251;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.28231>; else goto <D.28232>;
        <D.28231>:
        code.2099 = code;
        code.2562 = code.2099;
        code.2563 = code.2562 + 1;
        code = code.2563;
        D.28235 = _amd64_rex_bits | 64;
        *code.2562 = D.28235;
        <D.28232>:
      }
      code.2099 = code;
      code.2564 = code.2099;
      code.2565 = code.2564 + 1;
      code = code.2565;
      *code.2564 = 80;
      if (aot != 0) goto <D.28238>; else goto <D.28239>;
      <D.28238>:
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.27647 = (int) D.27646;
      ji = mono_patch_info_list_prepend (ji, D.27647, 32, "mono_amd64_throw_exception");
      if (0 != 0) goto <D.28240>; else goto <D.28241>;
      <D.28240>:
      code.2099 = code;
      code.2566 = code.2099;
      code.2567 = code.2566 + 1;
      code = code.2567;
      *code.2566 = 102;
      <D.28241>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.28244>; else goto <D.28245>;
        <D.28244>:
        code.2099 = code;
        code.2568 = code.2099;
        code.2569 = code.2568 + 1;
        code = code.2569;
        D.28248 = _amd64_rex_bits | 64;
        *code.2568 = D.28248;
        <D.28245>:
      }
      switch (8) <default: <D.23430>, case 1: <D.23425>, case 2: <D.23427>, case 4: <D.23428>, case 8: <D.23429>>
      <D.23425>:
      code.2099 = code;
      code.2570 = code.2099;
      code.2571 = code.2570 + 1;
      code = code.2571;
      *code.2570 = 138;
      goto <D.23426>;
      <D.23427>:
      <D.23428>:
      <D.23429>:
      code.2099 = code;
      code.2572 = code.2099;
      code.2573 = code.2572 + 1;
      code = code.2573;
      *code.2572 = 139;
      goto <D.23426>;
      <D.23430>:
      __assert_fail ("0", "exceptions-amd64.c", 1033, &__PRETTY_FUNCTION__);
      <D.23426>:
      if (1 != 0) goto <D.28253>; else goto <D.28254>;
      <D.28253>:
      code.2099 = code;
      code.2574 = code.2099;
      code.2575 = code.2574 + 1;
      code = code.2575;
      *code.2574 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2576 = code.2099;
            code.2577 = code.2576 + 1;
            code = code.2577;
            D.28259 = imb.b[0];
            *code.2576 = D.28259;
            code.2099 = code;
            code.2578 = code.2099;
            code.2579 = code.2578 + 1;
            code = code.2579;
            D.28262 = imb.b[1];
            *code.2578 = D.28262;
            code.2099 = code;
            code.2580 = code.2099;
            code.2581 = code.2580 + 1;
            code = code.2581;
            D.28265 = imb.b[2];
            *code.2580 = D.28265;
            code.2099 = code;
            code.2582 = code.2099;
            code.2583 = code.2582 + 1;
            code = code.2583;
            D.28268 = imb.b[3];
            *code.2582 = D.28268;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28269>;
      <D.28254>:
      if (0 != 0) goto <D.28270>; else goto <D.28271>;
      <D.28270>:
      if (1 != 0) goto <D.28272>; else goto <D.28273>;
      <D.28272>:
      code.2099 = code;
      code.2584 = code.2099;
      code.2585 = code.2584 + 1;
      code = code.2585;
      *code.2584 = 28;
      code.2099 = code;
      code.2586 = code.2099;
      code.2587 = code.2586 + 1;
      code = code.2587;
      *code.2586 = 36;
      goto <D.28278>;
      <D.28273>:
      if (1 != 0) goto <D.28279>; else goto <D.28280>;
      <D.28279>:
      code.2099 = code;
      code.2588 = code.2099;
      code.2589 = code.2588 + 1;
      code = code.2589;
      *code.2588 = 92;
      code.2099 = code;
      code.2590 = code.2099;
      code.2591 = code.2590 + 1;
      code = code.2591;
      *code.2590 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28285>;
      <D.28280>:
      code.2099 = code;
      code.2592 = code.2099;
      code.2593 = code.2592 + 1;
      code = code.2593;
      *code.2592 = 156;
      code.2099 = code;
      code.2594 = code.2099;
      code.2595 = code.2594 + 1;
      code = code.2595;
      *code.2594 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2596 = code.2099;
            code.2597 = code.2596 + 1;
            code = code.2597;
            D.28292 = imb.b[0];
            *code.2596 = D.28292;
            code.2099 = code;
            code.2598 = code.2099;
            code.2599 = code.2598 + 1;
            code = code.2599;
            D.28295 = imb.b[1];
            *code.2598 = D.28295;
            code.2099 = code;
            code.2600 = code.2099;
            code.2601 = code.2600 + 1;
            code = code.2601;
            D.28298 = imb.b[2];
            *code.2600 = D.28298;
            code.2099 = code;
            code.2602 = code.2099;
            code.2603 = code.2602 + 1;
            code = code.2603;
            D.28301 = imb.b[3];
            *code.2602 = D.28301;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28285>:
      <D.28278>:
      goto <D.23433>;
      <D.28271>:
      if (1 != 0) goto <D.28302>; else goto <D.28303>;
      <D.28302>:
      code.2099 = code;
      code.2604 = code.2099;
      code.2605 = code.2604 + 1;
      code = code.2605;
      *code.2604 = 24;
      goto <D.23433>;
      <D.28303>:
      if (1 != 0) goto <D.28306>; else goto <D.28307>;
      <D.28306>:
      code.2099 = code;
      code.2606 = code.2099;
      code.2607 = code.2606 + 1;
      code = code.2607;
      *code.2606 = 88;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28310>;
      <D.28307>:
      code.2099 = code;
      code.2608 = code.2099;
      code.2609 = code.2608 + 1;
      code = code.2609;
      *code.2608 = 152;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2610 = code.2099;
            code.2611 = code.2610 + 1;
            code = code.2611;
            D.28315 = imb.b[0];
            *code.2610 = D.28315;
            code.2099 = code;
            code.2612 = code.2099;
            code.2613 = code.2612 + 1;
            code = code.2613;
            D.28318 = imb.b[1];
            *code.2612 = D.28318;
            code.2099 = code;
            code.2614 = code.2099;
            code.2615 = code.2614 + 1;
            code = code.2615;
            D.28321 = imb.b[2];
            *code.2614 = D.28321;
            code.2099 = code;
            code.2616 = code.2099;
            code.2617 = code.2616 + 1;
            code = code.2617;
            D.28324 = imb.b[3];
            *code.2616 = D.28324;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28310>:
      <D.23433>:
      <D.28269>:
      goto <D.28325>;
      <D.28239>:
      throw_trampoline = mono_get_throw_exception ();
      {
        int _amd64_width_temp;

        throw_trampoline.2618 = (long unsigned int) throw_trampoline;
        throw_trampoline.2619 = (long int) throw_trampoline;
        D.28328 = (int) throw_trampoline.2619;
        D.28329 = (long unsigned int) D.28328;
        D.28330 = throw_trampoline.2618 == D.28329;
        _amd64_width_temp = (int) D.28330;
        {
          unsigned char _amd64_rex_bits;

          if (_amd64_width_temp == 0) goto <D.28332>; else goto <D.28333>;
          <D.28332>:
          iftmp.2620 = 9;
          goto <D.28334>;
          <D.28333>:
          iftmp.2620 = 1;
          <D.28334>:
          _amd64_rex_bits = iftmp.2620;
          if (_amd64_rex_bits != 0) goto <D.28335>; else goto <D.28336>;
          <D.28335>:
          code.2099 = code;
          code.2621 = code.2099;
          code.2622 = code.2621 + 1;
          code = code.2622;
          D.28339 = _amd64_rex_bits | 64;
          *code.2621 = D.28339;
          <D.28336>:
        }
        code.2099 = code;
        code.2623 = code.2099;
        code.2624 = code.2623 + 1;
        code = code.2624;
        *code.2623 = 187;
        if (_amd64_width_temp == 0) goto <D.28342>; else goto <D.28343>;
        <D.28342>:
        {
          union amd64_imm_buf imb;

          try
            {
              throw_trampoline.2618 = (long unsigned int) throw_trampoline;
              imb.val = throw_trampoline.2618;
              code.2099 = code;
              code.2625 = code.2099;
              code.2626 = code.2625 + 1;
              code = code.2626;
              D.28346 = imb.b[0];
              *code.2625 = D.28346;
              code.2099 = code;
              code.2627 = code.2099;
              code.2628 = code.2627 + 1;
              code = code.2628;
              D.28349 = imb.b[1];
              *code.2627 = D.28349;
              code.2099 = code;
              code.2629 = code.2099;
              code.2630 = code.2629 + 1;
              code = code.2630;
              D.28352 = imb.b[2];
              *code.2629 = D.28352;
              code.2099 = code;
              code.2631 = code.2099;
              code.2632 = code.2631 + 1;
              code = code.2632;
              D.28355 = imb.b[3];
              *code.2631 = D.28355;
              code.2099 = code;
              code.2633 = code.2099;
              code.2634 = code.2633 + 1;
              code = code.2634;
              D.28358 = imb.b[4];
              *code.2633 = D.28358;
              code.2099 = code;
              code.2635 = code.2099;
              code.2636 = code.2635 + 1;
              code = code.2636;
              D.28361 = imb.b[5];
              *code.2635 = D.28361;
              code.2099 = code;
              code.2637 = code.2099;
              code.2638 = code.2637 + 1;
              code = code.2638;
              D.28364 = imb.b[6];
              *code.2637 = D.28364;
              code.2099 = code;
              code.2639 = code.2099;
              code.2640 = code.2639 + 1;
              code = code.2640;
              D.28367 = imb.b[7];
              *code.2639 = D.28367;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28368>;
        <D.28343>:
        {
          union x86_imm_buf imb;

          try
            {
              throw_trampoline.2619 = (long int) throw_trampoline;
              D.28328 = (int) throw_trampoline.2619;
              imb.val = D.28328;
              code.2099 = code;
              code.2641 = code.2099;
              code.2642 = code.2641 + 1;
              code = code.2642;
              D.28371 = imb.b[0];
              *code.2641 = D.28371;
              code.2099 = code;
              code.2643 = code.2099;
              code.2644 = code.2643 + 1;
              code = code.2644;
              D.28374 = imb.b[1];
              *code.2643 = D.28374;
              code.2099 = code;
              code.2645 = code.2099;
              code.2646 = code.2645 + 1;
              code = code.2646;
              D.28377 = imb.b[2];
              *code.2645 = D.28377;
              code.2099 = code;
              code.2647 = code.2099;
              code.2648 = code.2647 + 1;
              code = code.2648;
              D.28380 = imb.b[3];
              *code.2647 = D.28380;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28368>:
      }
      <D.28325>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.28381>; else goto <D.28382>;
        <D.28381>:
        code.2099 = code;
        code.2649 = code.2099;
        code.2650 = code.2649 + 1;
        code = code.2650;
        D.28385 = _amd64_rex_bits | 64;
        *code.2649 = D.28385;
        <D.28382>:
      }
      code.2099 = code;
      code.2651 = code.2099;
      code.2652 = code.2651 + 1;
      code = code.2652;
      *code.2651 = 255;
      code.2099 = code;
      code.2653 = code.2099;
      code.2654 = code.2653 + 1;
      code = code.2654;
      *code.2653 = 227;
      code.2099 = code;
      D.28390 = br[0];
      mono_amd64_patch (D.28390, code.2099);
      if (aot != 0) goto <D.28391>; else goto <D.28392>;
      <D.28391>:
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.27647 = (int) D.27646;
      ji = mono_patch_info_list_prepend (ji, D.27647, 32, "mono_amd64_get_original_ip");
      if (0 != 0) goto <D.28393>; else goto <D.28394>;
      <D.28393>:
      code.2099 = code;
      code.2655 = code.2099;
      code.2656 = code.2655 + 1;
      code = code.2656;
      *code.2655 = 102;
      <D.28394>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 13;
        if (_amd64_rex_bits != 0) goto <D.28397>; else goto <D.28398>;
        <D.28397>:
        code.2099 = code;
        code.2657 = code.2099;
        code.2658 = code.2657 + 1;
        code = code.2658;
        D.28401 = _amd64_rex_bits | 64;
        *code.2657 = D.28401;
        <D.28398>:
      }
      switch (8) <default: <D.23446>, case 1: <D.23441>, case 2: <D.23443>, case 4: <D.23444>, case 8: <D.23445>>
      <D.23441>:
      code.2099 = code;
      code.2659 = code.2099;
      code.2660 = code.2659 + 1;
      code = code.2660;
      *code.2659 = 138;
      goto <D.23442>;
      <D.23443>:
      <D.23444>:
      <D.23445>:
      code.2099 = code;
      code.2661 = code.2099;
      code.2662 = code.2661 + 1;
      code = code.2662;
      *code.2661 = 139;
      goto <D.23442>;
      <D.23446>:
      __assert_fail ("0", "exceptions-amd64.c", 1047, &__PRETTY_FUNCTION__);
      <D.23442>:
      if (1 != 0) goto <D.28406>; else goto <D.28407>;
      <D.28406>:
      code.2099 = code;
      code.2663 = code.2099;
      code.2664 = code.2663 + 1;
      code = code.2664;
      *code.2663 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2665 = code.2099;
            code.2666 = code.2665 + 1;
            code = code.2666;
            D.28412 = imb.b[0];
            *code.2665 = D.28412;
            code.2099 = code;
            code.2667 = code.2099;
            code.2668 = code.2667 + 1;
            code = code.2668;
            D.28415 = imb.b[1];
            *code.2667 = D.28415;
            code.2099 = code;
            code.2669 = code.2099;
            code.2670 = code.2669 + 1;
            code = code.2670;
            D.28418 = imb.b[2];
            *code.2669 = D.28418;
            code.2099 = code;
            code.2671 = code.2099;
            code.2672 = code.2671 + 1;
            code = code.2672;
            D.28421 = imb.b[3];
            *code.2671 = D.28421;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28422>;
      <D.28407>:
      if (0 != 0) goto <D.28423>; else goto <D.28424>;
      <D.28423>:
      if (1 != 0) goto <D.28425>; else goto <D.28426>;
      <D.28425>:
      code.2099 = code;
      code.2673 = code.2099;
      code.2674 = code.2673 + 1;
      code = code.2674;
      *code.2673 = 28;
      code.2099 = code;
      code.2675 = code.2099;
      code.2676 = code.2675 + 1;
      code = code.2676;
      *code.2675 = 36;
      goto <D.28431>;
      <D.28426>:
      if (1 != 0) goto <D.28432>; else goto <D.28433>;
      <D.28432>:
      code.2099 = code;
      code.2677 = code.2099;
      code.2678 = code.2677 + 1;
      code = code.2678;
      *code.2677 = 92;
      code.2099 = code;
      code.2679 = code.2099;
      code.2680 = code.2679 + 1;
      code = code.2680;
      *code.2679 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28438>;
      <D.28433>:
      code.2099 = code;
      code.2681 = code.2099;
      code.2682 = code.2681 + 1;
      code = code.2682;
      *code.2681 = 156;
      code.2099 = code;
      code.2683 = code.2099;
      code.2684 = code.2683 + 1;
      code = code.2684;
      *code.2683 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2685 = code.2099;
            code.2686 = code.2685 + 1;
            code = code.2686;
            D.28445 = imb.b[0];
            *code.2685 = D.28445;
            code.2099 = code;
            code.2687 = code.2099;
            code.2688 = code.2687 + 1;
            code = code.2688;
            D.28448 = imb.b[1];
            *code.2687 = D.28448;
            code.2099 = code;
            code.2689 = code.2099;
            code.2690 = code.2689 + 1;
            code = code.2690;
            D.28451 = imb.b[2];
            *code.2689 = D.28451;
            code.2099 = code;
            code.2691 = code.2099;
            code.2692 = code.2691 + 1;
            code = code.2692;
            D.28454 = imb.b[3];
            *code.2691 = D.28454;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28438>:
      <D.28431>:
      goto <D.23449>;
      <D.28424>:
      if (1 != 0) goto <D.28455>; else goto <D.28456>;
      <D.28455>:
      code.2099 = code;
      code.2693 = code.2099;
      code.2694 = code.2693 + 1;
      code = code.2694;
      *code.2693 = 24;
      goto <D.23449>;
      <D.28456>:
      if (1 != 0) goto <D.28459>; else goto <D.28460>;
      <D.28459>:
      code.2099 = code;
      code.2695 = code.2099;
      code.2696 = code.2695 + 1;
      code = code.2696;
      *code.2695 = 88;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28463>;
      <D.28460>:
      code.2099 = code;
      code.2697 = code.2099;
      code.2698 = code.2697 + 1;
      code = code.2698;
      *code.2697 = 152;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2699 = code.2099;
            code.2700 = code.2699 + 1;
            code = code.2700;
            D.28468 = imb.b[0];
            *code.2699 = D.28468;
            code.2099 = code;
            code.2701 = code.2099;
            code.2702 = code.2701 + 1;
            code = code.2702;
            D.28471 = imb.b[1];
            *code.2701 = D.28471;
            code.2099 = code;
            code.2703 = code.2099;
            code.2704 = code.2703 + 1;
            code = code.2704;
            D.28474 = imb.b[2];
            *code.2703 = D.28474;
            code.2099 = code;
            code.2705 = code.2099;
            code.2706 = code.2705 + 1;
            code = code.2706;
            D.28477 = imb.b[3];
            *code.2705 = D.28477;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28463>:
      <D.23449>:
      <D.28422>:
      goto <D.28478>;
      <D.28392>:
      {
        int _amd64_width_temp;

        mono_amd64_get_original_ip.2431 = (long int) mono_amd64_get_original_ip;
        D.28013 = (int) mono_amd64_get_original_ip.2431;
        D.28014 = (long unsigned int) D.28013;
        mono_amd64_get_original_ip.2432 = (long unsigned int) mono_amd64_get_original_ip;
        D.28016 = D.28014 == mono_amd64_get_original_ip.2432;
        _amd64_width_temp = (int) D.28016;
        {
          unsigned char _amd64_rex_bits;

          if (_amd64_width_temp == 0) goto <D.28480>; else goto <D.28481>;
          <D.28480>:
          iftmp.2707 = 9;
          goto <D.28482>;
          <D.28481>:
          iftmp.2707 = 1;
          <D.28482>:
          _amd64_rex_bits = iftmp.2707;
          if (_amd64_rex_bits != 0) goto <D.28483>; else goto <D.28484>;
          <D.28483>:
          code.2099 = code;
          code.2708 = code.2099;
          code.2709 = code.2708 + 1;
          code = code.2709;
          D.28487 = _amd64_rex_bits | 64;
          *code.2708 = D.28487;
          <D.28484>:
        }
        code.2099 = code;
        code.2710 = code.2099;
        code.2711 = code.2710 + 1;
        code = code.2711;
        *code.2710 = 187;
        if (_amd64_width_temp == 0) goto <D.28490>; else goto <D.28491>;
        <D.28490>:
        {
          union amd64_imm_buf imb;

          try
            {
              mono_amd64_get_original_ip.2432 = (long unsigned int) mono_amd64_get_original_ip;
              imb.val = mono_amd64_get_original_ip.2432;
              code.2099 = code;
              code.2712 = code.2099;
              code.2713 = code.2712 + 1;
              code = code.2713;
              D.28494 = imb.b[0];
              *code.2712 = D.28494;
              code.2099 = code;
              code.2714 = code.2099;
              code.2715 = code.2714 + 1;
              code = code.2715;
              D.28497 = imb.b[1];
              *code.2714 = D.28497;
              code.2099 = code;
              code.2716 = code.2099;
              code.2717 = code.2716 + 1;
              code = code.2717;
              D.28500 = imb.b[2];
              *code.2716 = D.28500;
              code.2099 = code;
              code.2718 = code.2099;
              code.2719 = code.2718 + 1;
              code = code.2719;
              D.28503 = imb.b[3];
              *code.2718 = D.28503;
              code.2099 = code;
              code.2720 = code.2099;
              code.2721 = code.2720 + 1;
              code = code.2721;
              D.28506 = imb.b[4];
              *code.2720 = D.28506;
              code.2099 = code;
              code.2722 = code.2099;
              code.2723 = code.2722 + 1;
              code = code.2723;
              D.28509 = imb.b[5];
              *code.2722 = D.28509;
              code.2099 = code;
              code.2724 = code.2099;
              code.2725 = code.2724 + 1;
              code = code.2725;
              D.28512 = imb.b[6];
              *code.2724 = D.28512;
              code.2099 = code;
              code.2726 = code.2099;
              code.2727 = code.2726 + 1;
              code = code.2727;
              D.28515 = imb.b[7];
              *code.2726 = D.28515;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        goto <D.28516>;
        <D.28491>:
        {
          union x86_imm_buf imb;

          try
            {
              mono_amd64_get_original_ip.2431 = (long int) mono_amd64_get_original_ip;
              D.28013 = (int) mono_amd64_get_original_ip.2431;
              imb.val = D.28013;
              code.2099 = code;
              code.2728 = code.2099;
              code.2729 = code.2728 + 1;
              code = code.2729;
              D.28519 = imb.b[0];
              *code.2728 = D.28519;
              code.2099 = code;
              code.2730 = code.2099;
              code.2731 = code.2730 + 1;
              code = code.2731;
              D.28522 = imb.b[1];
              *code.2730 = D.28522;
              code.2099 = code;
              code.2732 = code.2099;
              code.2733 = code.2732 + 1;
              code = code.2733;
              D.28525 = imb.b[2];
              *code.2732 = D.28525;
              code.2099 = code;
              code.2734 = code.2099;
              code.2735 = code.2734 + 1;
              code = code.2735;
              D.28528 = imb.b[3];
              *code.2734 = D.28528;
            }
          finally
            {
              imb = {CLOBBER};
            }
        }
        <D.28516>:
      }
      <D.28478>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.28529>; else goto <D.28530>;
        <D.28529>:
        code.2099 = code;
        code.2736 = code.2099;
        code.2737 = code.2736 + 1;
        code = code.2737;
        D.28533 = _amd64_rex_bits | 64;
        *code.2736 = D.28533;
        <D.28530>:
      }
      code.2099 = code;
      code.2738 = code.2099;
      code.2739 = code.2738 + 1;
      code = code.2739;
      *code.2738 = 255;
      code.2099 = code;
      code.2740 = code.2099;
      code.2741 = code.2740 + 1;
      code = code.2741;
      *code.2740 = 211;
      if (0 != 0) goto <D.28538>; else goto <D.28539>;
      <D.28538>:
      code.2099 = code;
      code.2742 = code.2099;
      code.2743 = code.2742 + 1;
      code = code.2743;
      *code.2742 = 102;
      <D.28539>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.28542>; else goto <D.28543>;
        <D.28542>:
        code.2099 = code;
        code.2744 = code.2099;
        code.2745 = code.2744 + 1;
        code = code.2745;
        D.28546 = _amd64_rex_bits | 64;
        *code.2744 = D.28546;
        <D.28543>:
      }
      switch (8) <default: <D.23462>, case 1: <D.23457>, case 2: <D.23459>, case 4: <D.23460>, case 8: <D.23461>>
      <D.23457>:
      code.2099 = code;
      code.2746 = code.2099;
      code.2747 = code.2746 + 1;
      code = code.2747;
      *code.2746 = 138;
      goto <D.23458>;
      <D.23459>:
      <D.23460>:
      <D.23461>:
      code.2099 = code;
      code.2748 = code.2099;
      code.2749 = code.2748 + 1;
      code = code.2749;
      *code.2748 = 139;
      goto <D.23458>;
      <D.23462>:
      __assert_fail ("0", "exceptions-amd64.c", 1052, &__PRETTY_FUNCTION__);
      <D.23458>:
      code.2099 = code;
      code.2750 = code.2099;
      code.2751 = code.2750 + 1;
      code = code.2751;
      *code.2750 = 216;
      if (1 != 0) goto <D.28553>; else goto <D.28554>;
      <D.28553>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28555>; else goto <D.28556>;
        <D.28555>:
        code.2099 = code;
        code.2752 = code.2099;
        code.2753 = code.2752 + 1;
        code = code.2753;
        D.28559 = _amd64_rex_bits | 64;
        *code.2752 = D.28559;
        <D.28556>:
      }
      code.2099 = code;
      code.2754 = code.2099;
      code.2755 = code.2754 + 1;
      code = code.2755;
      *code.2754 = 131;
      code.2099 = code;
      code.2756 = code.2099;
      code.2757 = code.2756 + 1;
      code = code.2757;
      *code.2756 = 196;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28564>;
      <D.28554>:
      if (0 != 0) goto <D.28565>; else goto <D.28566>;
      <D.28565>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28567>; else goto <D.28568>;
        <D.28567>:
        code.2099 = code;
        code.2758 = code.2099;
        code.2759 = code.2758 + 1;
        code = code.2759;
        D.28571 = _amd64_rex_bits | 64;
        *code.2758 = D.28571;
        <D.28568>:
      }
      code.2099 = code;
      code.2760 = code.2099;
      code.2761 = code.2760 + 1;
      code = code.2761;
      *code.2760 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2762 = code.2099;
            code.2763 = code.2762 + 1;
            code = code.2763;
            D.28576 = imb.b[0];
            *code.2762 = D.28576;
            code.2099 = code;
            code.2764 = code.2099;
            code.2765 = code.2764 + 1;
            code = code.2765;
            D.28579 = imb.b[1];
            *code.2764 = D.28579;
            code.2099 = code;
            code.2766 = code.2099;
            code.2767 = code.2766 + 1;
            code = code.2767;
            D.28582 = imb.b[2];
            *code.2766 = D.28582;
            code.2099 = code;
            code.2768 = code.2099;
            code.2769 = code.2768 + 1;
            code = code.2769;
            D.28585 = imb.b[3];
            *code.2768 = D.28585;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28586>;
      <D.28566>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28587>; else goto <D.28588>;
        <D.28587>:
        code.2099 = code;
        code.2770 = code.2099;
        code.2771 = code.2770 + 1;
        code = code.2771;
        D.28591 = _amd64_rex_bits | 64;
        *code.2770 = D.28591;
        <D.28588>:
      }
      code.2099 = code;
      code.2772 = code.2099;
      code.2773 = code.2772 + 1;
      code = code.2773;
      *code.2772 = 129;
      code.2099 = code;
      code.2774 = code.2099;
      code.2775 = code.2774 + 1;
      code = code.2775;
      *code.2774 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2776 = code.2099;
            code.2777 = code.2776 + 1;
            code = code.2777;
            D.28598 = imb.b[0];
            *code.2776 = D.28598;
            code.2099 = code;
            code.2778 = code.2099;
            code.2779 = code.2778 + 1;
            code = code.2779;
            D.28601 = imb.b[1];
            *code.2778 = D.28601;
            code.2099 = code;
            code.2780 = code.2099;
            code.2781 = code.2780 + 1;
            code = code.2781;
            D.28604 = imb.b[2];
            *code.2780 = D.28604;
            code.2099 = code;
            code.2782 = code.2099;
            code.2783 = code.2782 + 1;
            code = code.2783;
            D.28607 = imb.b[3];
            *code.2782 = D.28607;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28586>:
      <D.28564>:
      code.2099 = code;
      code.2784 = code.2099;
      code.2785 = code.2784 + 1;
      code = code.2785;
      *code.2784 = 242;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.28610>; else goto <D.28611>;
        <D.28610>:
        code.2099 = code;
        code.2786 = code.2099;
        code.2787 = code.2786 + 1;
        code = code.2787;
        D.28614 = _amd64_rex_bits | 64;
        *code.2786 = D.28614;
        <D.28611>:
      }
      code.2099 = code;
      code.2788 = code.2099;
      code.2789 = code.2788 + 1;
      code = code.2789;
      *code.2788 = 15;
      code.2099 = code;
      code.2790 = code.2099;
      code.2791 = code.2790 + 1;
      code = code.2791;
      *code.2790 = 16;
      if (1 != 0) goto <D.28619>; else goto <D.28620>;
      <D.28619>:
      if (1 != 0) goto <D.28621>; else goto <D.28622>;
      <D.28621>:
      code.2099 = code;
      code.2792 = code.2099;
      code.2793 = code.2792 + 1;
      code = code.2793;
      *code.2792 = 4;
      code.2099 = code;
      code.2794 = code.2099;
      code.2795 = code.2794 + 1;
      code = code.2795;
      *code.2794 = 36;
      goto <D.28627>;
      <D.28622>:
      if (1 != 0) goto <D.28628>; else goto <D.28629>;
      <D.28628>:
      code.2099 = code;
      code.2796 = code.2099;
      code.2797 = code.2796 + 1;
      code = code.2797;
      *code.2796 = 68;
      code.2099 = code;
      code.2798 = code.2099;
      code.2799 = code.2798 + 1;
      code = code.2799;
      *code.2798 = 36;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28634>;
      <D.28629>:
      code.2099 = code;
      code.2800 = code.2099;
      code.2801 = code.2800 + 1;
      code = code.2801;
      *code.2800 = 132;
      code.2099 = code;
      code.2802 = code.2099;
      code.2803 = code.2802 + 1;
      code = code.2803;
      *code.2802 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2804 = code.2099;
            code.2805 = code.2804 + 1;
            code = code.2805;
            D.28641 = imb.b[0];
            *code.2804 = D.28641;
            code.2099 = code;
            code.2806 = code.2099;
            code.2807 = code.2806 + 1;
            code = code.2807;
            D.28644 = imb.b[1];
            *code.2806 = D.28644;
            code.2099 = code;
            code.2808 = code.2099;
            code.2809 = code.2808 + 1;
            code = code.2809;
            D.28647 = imb.b[2];
            *code.2808 = D.28647;
            code.2099 = code;
            code.2810 = code.2099;
            code.2811 = code.2810 + 1;
            code = code.2811;
            D.28650 = imb.b[3];
            *code.2810 = D.28650;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28634>:
      <D.28627>:
      goto <D.23470>;
      <D.28620>:
      if (1 != 0) goto <D.28651>; else goto <D.28652>;
      <D.28651>:
      code.2099 = code;
      code.2812 = code.2099;
      code.2813 = code.2812 + 1;
      code = code.2813;
      *code.2812 = 4;
      goto <D.23470>;
      <D.28652>:
      if (1 != 0) goto <D.28655>; else goto <D.28656>;
      <D.28655>:
      code.2099 = code;
      code.2814 = code.2099;
      code.2815 = code.2814 + 1;
      code = code.2815;
      *code.2814 = 68;
      code.2099 = code;
      *code.2099 = 0;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28659>;
      <D.28656>:
      code.2099 = code;
      code.2816 = code.2099;
      code.2817 = code.2816 + 1;
      code = code.2817;
      *code.2816 = 132;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2099 = code;
            code.2818 = code.2099;
            code.2819 = code.2818 + 1;
            code = code.2819;
            D.28664 = imb.b[0];
            *code.2818 = D.28664;
            code.2099 = code;
            code.2820 = code.2099;
            code.2821 = code.2820 + 1;
            code = code.2821;
            D.28667 = imb.b[1];
            *code.2820 = D.28667;
            code.2099 = code;
            code.2822 = code.2099;
            code.2823 = code.2822 + 1;
            code = code.2823;
            D.28670 = imb.b[2];
            *code.2822 = D.28670;
            code.2099 = code;
            code.2824 = code.2099;
            code.2825 = code.2824 + 1;
            code = code.2825;
            D.28673 = imb.b[3];
            *code.2824 = D.28673;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28659>:
      <D.23470>:
      if (1 != 0) goto <D.28674>; else goto <D.28675>;
      <D.28674>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28676>; else goto <D.28677>;
        <D.28676>:
        code.2099 = code;
        code.2826 = code.2099;
        code.2827 = code.2826 + 1;
        code = code.2827;
        D.28680 = _amd64_rex_bits | 64;
        *code.2826 = D.28680;
        <D.28677>:
      }
      code.2099 = code;
      code.2828 = code.2099;
      code.2829 = code.2828 + 1;
      code = code.2829;
      *code.2828 = 131;
      code.2099 = code;
      code.2830 = code.2099;
      code.2831 = code.2830 + 1;
      code = code.2831;
      *code.2830 = 196;
      code.2099 = code;
      *code.2099 = 8;
      code.2099 = code;
      code.2114 = code.2099 + 1;
      code = code.2114;
      goto <D.28685>;
      <D.28675>:
      if (0 != 0) goto <D.28686>; else goto <D.28687>;
      <D.28686>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28688>; else goto <D.28689>;
        <D.28688>:
        code.2099 = code;
        code.2832 = code.2099;
        code.2833 = code.2832 + 1;
        code = code.2833;
        D.28692 = _amd64_rex_bits | 64;
        *code.2832 = D.28692;
        <D.28689>:
      }
      code.2099 = code;
      code.2834 = code.2099;
      code.2835 = code.2834 + 1;
      code = code.2835;
      *code.2834 = 5;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2836 = code.2099;
            code.2837 = code.2836 + 1;
            code = code.2837;
            D.28697 = imb.b[0];
            *code.2836 = D.28697;
            code.2099 = code;
            code.2838 = code.2099;
            code.2839 = code.2838 + 1;
            code = code.2839;
            D.28700 = imb.b[1];
            *code.2838 = D.28700;
            code.2099 = code;
            code.2840 = code.2099;
            code.2841 = code.2840 + 1;
            code = code.2841;
            D.28703 = imb.b[2];
            *code.2840 = D.28703;
            code.2099 = code;
            code.2842 = code.2099;
            code.2843 = code.2842 + 1;
            code = code.2843;
            D.28706 = imb.b[3];
            *code.2842 = D.28706;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28707>;
      <D.28687>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28708>; else goto <D.28709>;
        <D.28708>:
        code.2099 = code;
        code.2844 = code.2099;
        code.2845 = code.2844 + 1;
        code = code.2845;
        D.28712 = _amd64_rex_bits | 64;
        *code.2844 = D.28712;
        <D.28709>:
      }
      code.2099 = code;
      code.2846 = code.2099;
      code.2847 = code.2846 + 1;
      code = code.2847;
      *code.2846 = 129;
      code.2099 = code;
      code.2848 = code.2099;
      code.2849 = code.2848 + 1;
      code = code.2849;
      *code.2848 = 196;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 8;
            code.2099 = code;
            code.2850 = code.2099;
            code.2851 = code.2850 + 1;
            code = code.2851;
            D.28719 = imb.b[0];
            *code.2850 = D.28719;
            code.2099 = code;
            code.2852 = code.2099;
            code.2853 = code.2852 + 1;
            code = code.2853;
            D.28722 = imb.b[1];
            *code.2852 = D.28722;
            code.2099 = code;
            code.2854 = code.2099;
            code.2855 = code.2854 + 1;
            code = code.2855;
            D.28725 = imb.b[2];
            *code.2854 = D.28725;
            code.2099 = code;
            code.2856 = code.2099;
            code.2857 = code.2856 + 1;
            code = code.2857;
            D.28728 = imb.b[3];
            *code.2856 = D.28728;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28707>:
      <D.28685>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.28729>; else goto <D.28730>;
        <D.28729>:
        code.2099 = code;
        code.2858 = code.2099;
        code.2859 = code.2858 + 1;
        code = code.2859;
        D.28733 = _amd64_rex_bits | 64;
        *code.2858 = D.28733;
        <D.28730>:
      }
      code.2099 = code;
      code.2860 = code.2099;
      code.2861 = code.2860 + 1;
      code = code.2861;
      *code.2860 = 90;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 0;
        if (_amd64_rex_bits != 0) goto <D.28736>; else goto <D.28737>;
        <D.28736>:
        code.2099 = code;
        code.2862 = code.2099;
        code.2863 = code.2862 + 1;
        code = code.2863;
        D.28740 = _amd64_rex_bits | 64;
        *code.2862 = D.28740;
        <D.28737>:
      }
      code.2099 = code;
      code.2864 = code.2099;
      code.2865 = code.2864 + 1;
      code = code.2865;
      *code.2864 = 88;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 1;
        if (_amd64_rex_bits != 0) goto <D.28743>; else goto <D.28744>;
        <D.28743>:
        code.2099 = code;
        code.2866 = code.2099;
        code.2867 = code.2866 + 1;
        code = code.2867;
        D.28747 = _amd64_rex_bits | 64;
        *code.2866 = D.28747;
        <D.28744>:
      }
      code.2099 = code;
      code.2868 = code.2099;
      code.2869 = code.2868 + 1;
      code = code.2869;
      *code.2868 = 255;
      code.2099 = code;
      code.2870 = code.2099;
      code.2871 = code.2870 + 1;
      code = code.2871;
      *code.2870 = 227;
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.28752 = D.27646 > 127;
      D.28753 = (long int) D.28752;
      D.28754 = __builtin_expect (D.28753, 0);
      if (D.28754 != 0) goto <D.28755>; else goto <D.28756>;
      <D.28755>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 1064, "(code - start) < kMaxCodeSize");
      <D.28756>:
      kMaxCodeSize.2097 = (int) kMaxCodeSize;
      nacl_global_codeman_validate (&start, kMaxCodeSize.2097, &code);
      if (info != 0B) goto <D.28757>; else goto <D.28758>;
      <D.28757>:
      code.2099 = code;
      code.2215 = (long int) code.2099;
      start.2216 = start;
      start.2217 = (long int) start.2216;
      D.27646 = code.2215 - start.2217;
      D.28759 = (unsigned int) D.27646;
      start.2216 = start;
      D.28760 = mono_tramp_info_create ("throw_pending_exception", start.2216, D.28759, ji, unwind_ops);
      *info = D.28760;
      <D.28758>:
      D.28761 = start;
      return D.28761;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
      br = {CLOBBER};
    }
}


mono_arch_notify_pending_exc ()
{
  long unsigned int D.28766;
  void * D.28769;
  long unsigned int D.28770;
  long unsigned int D.28771;
  long unsigned int D.28774;
  guint64 * D.28775;
  long unsigned int D.28776;
  long unsigned int D.28777;
  void * D.28778;
  void * * D.28779;
  void * throw_pending_exception.2872;
  struct MonoLMF * lmf;

  lmf = mono_get_lmf ();
  if (lmf == 0B) goto <D.28764>; else goto <D.28765>;
  <D.28764>:
  return;
  <D.28765>:
  D.28766 = lmf->rsp;
  if (D.28766 == 0) goto <D.28767>; else goto <D.28768>;
  <D.28767>:
  return;
  <D.28768>:
  D.28769 = lmf->previous_lmf;
  D.28770 = (long unsigned int) D.28769;
  D.28771 = D.28770 & 1;
  if (D.28771 != 0) goto <D.28772>; else goto <D.28773>;
  <D.28772>:
  return;
  <D.28773>:
  D.28766 = lmf->rsp;
  D.28774 = D.28766 + 18446744073709551608;
  D.28775 = (guint64 *) D.28774;
  D.28776 = *D.28775;
  lmf->rip = D.28776;
  D.28769 = lmf->previous_lmf;
  D.28770 = (long unsigned int) D.28769;
  D.28777 = D.28770 | 1;
  D.28778 = (void *) D.28777;
  lmf->previous_lmf = D.28778;
  D.28766 = lmf->rsp;
  D.28774 = D.28766 + 18446744073709551608;
  D.28779 = (void * *) D.28774;
  throw_pending_exception.2872 = throw_pending_exception;
  *D.28779 = throw_pending_exception.2872;
}


mono_amd64_get_exception_trampolines (gboolean aot)
{
  struct MonoTrampInfo * info.2873;
  struct GSList * D.28783;
  struct MonoTrampInfo * info;
  struct GSList * tramps;

  try
    {
      tramps = 0B;
      mono_arch_get_throw_pending_exception (&info, aot);
      info.2873 = info;
      tramps = monoeg_g_slist_prepend (tramps, info.2873);
      get_throw_trampoline (&info, 0, 1, 0, 0, "llvm_throw_corlib_exception_trampoline", aot);
      info.2873 = info;
      tramps = monoeg_g_slist_prepend (tramps, info.2873);
      get_throw_trampoline (&info, 0, 1, 1, 0, "llvm_throw_corlib_exception_abs_trampoline", aot);
      info.2873 = info;
      tramps = monoeg_g_slist_prepend (tramps, info.2873);
      get_throw_trampoline (&info, 0, 1, 1, 1, "llvm_resume_unwind_trampoline", 0);
      info.2873 = info;
      tramps = monoeg_g_slist_prepend (tramps, info.2873);
      D.28783 = tramps;
      return D.28783;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_arch_exceptions_init ()
{
  int mono_aot_only.2874;
  void * throw_pending_exception.2875;
  void * throw_pending_exception.2876;
  char * D.28792;
  gchar * D.28793;
  guint8 * D.28794;
  struct GSList * tramps;
  struct GSList * l;
  void * tramp;

  mono_aot_only.2874 = mono_aot_only;
  if (mono_aot_only.2874 != 0) goto <D.28787>; else goto <D.28788>;
  <D.28787>:
  throw_pending_exception.2875 = mono_aot_get_trampoline ("throw_pending_exception");
  throw_pending_exception = throw_pending_exception.2875;
  tramp = mono_aot_get_trampoline ("llvm_throw_corlib_exception_trampoline");
  mono_register_jit_icall (tramp, "llvm_throw_corlib_exception_trampoline", 0B, 1);
  tramp = mono_aot_get_trampoline ("llvm_throw_corlib_exception_abs_trampoline");
  mono_register_jit_icall (tramp, "llvm_throw_corlib_exception_abs_trampoline", 0B, 1);
  tramp = mono_aot_get_trampoline ("llvm_resume_unwind_trampoline");
  mono_register_jit_icall (tramp, "llvm_resume_unwind_trampoline", 0B, 1);
  goto <D.28790>;
  <D.28788>:
  throw_pending_exception.2876 = mono_arch_get_throw_pending_exception (0B, 0);
  throw_pending_exception = throw_pending_exception.2876;
  tramps = mono_amd64_get_exception_trampolines (0);
  l = tramps;
  goto <D.23498>;
  <D.23497>:
  {
    struct MonoTrampInfo * info;

    info = l->data;
    D.28792 = info->name;
    D.28793 = monoeg_strdup (D.28792);
    D.28794 = info->code;
    mono_register_jit_icall (D.28794, D.28793, 0B, 1);
    mono_tramp_info_register (info);
  }
  l = l->next;
  <D.23498>:
  if (l != 0B) goto <D.23497>; else goto <D.23499>;
  <D.23499>:
  monoeg_g_slist_free (tramps);
  <D.28790>:
}


monoeg_strdup (const gchar * str)
{
  gchar * D.28797;

  if (str != 0B) goto <D.28795>; else goto <D.28796>;
  <D.28795>:
  D.28797 = __strdup (str);
  return D.28797;
  <D.28796>:
  D.28797 = 0B;
  return D.28797;
}


mono_tasklets_arch_restore ()
{
  guint8 * saved.2877;
  void (*MonoContinuationRestore) (struct MonoContinuation *, int, struct MonoLMF * *) D.28802;
  int kMaxCodeSize.2878;
  void * start.2879;
  guint8 * start.2880;
  guint8 * code.2881;
  guint8 * code.2882;
  guint8 * code.2883;
  unsigned char iftmp.2884;
  guint8 * code.2885;
  guint8 * code.2886;
  unsigned char D.28819;
  guint8 * code.2887;
  guint8 * code.2888;
  guint8 * code.2889;
  guint8 * code.2890;
  guint8 * code.2891;
  guint8 * code.2892;
  int D.28826;
  int D.28827;
  signed char D.28828;
  signed char D.28829;
  unsigned char D.28830;
  guint8 * code.2893;
  guint8 * code.2894;
  guint8 * code.2895;
  guint8 * code.2896;
  unsigned char D.28839;
  guint8 * code.2897;
  guint8 * code.2898;
  guint8 * code.2899;
  guint8 * code.2900;
  guint8 * code.2901;
  guint8 * code.2902;
  guint8 * code.2903;
  guint8 * code.2904;
  _Bool D.28850;
  guint8 * code.2905;
  guint8 * code.2906;
  unsigned char D.28855;
  guint8 * code.2907;
  guint8 * code.2908;
  guint8 * code.2909;
  guint8 * code.2910;
  guint8 * code.2911;
  guint8 * code.2912;
  guint8 * code.2913;
  guint8 * code.2914;
  unsigned char D.28866;
  guint8 * code.2915;
  guint8 * code.2916;
  unsigned char D.28869;
  guint8 * code.2917;
  guint8 * code.2918;
  unsigned char D.28872;
  guint8 * code.2919;
  guint8 * code.2920;
  unsigned char D.28875;
  guint8 * code.2921;
  guint8 * code.2922;
  guint8 * code.2923;
  guint8 * code.2924;
  guint8 * code.2925;
  guint8 * code.2926;
  guint8 * code.2927;
  guint8 * code.2928;
  guint8 * code.2929;
  guint8 * code.2930;
  guint8 * code.2931;
  guint8 * code.2932;
  guint8 * code.2933;
  guint8 * code.2934;
  guint8 * code.2935;
  unsigned char D.28900;
  guint8 * code.2936;
  guint8 * code.2937;
  unsigned char D.28903;
  guint8 * code.2938;
  guint8 * code.2939;
  unsigned char D.28906;
  guint8 * code.2940;
  guint8 * code.2941;
  unsigned char D.28909;
  guint8 * code.2942;
  guint8 * code.2943;
  signed char D.28914;
  signed char D.28915;
  signed char D.28916;
  unsigned char D.28917;
  guint8 * code.2944;
  guint8 * code.2945;
  signed char D.28922;
  unsigned char D.28923;
  guint8 * code.2946;
  guint8 * code.2947;
  signed char D.28927;
  unsigned char D.28928;
  guint8 * code.2948;
  guint8 * code.2949;
  unsigned char D.28931;
  guint8 * code.2950;
  guint8 * code.2951;
  unsigned char D.28934;
  guint8 * code.2952;
  guint8 * code.2953;
  unsigned char D.28937;
  guint8 * code.2954;
  guint8 * code.2955;
  unsigned char D.28940;
  guint8 * code.2956;
  guint8 * code.2957;
  unsigned char D.28945;
  guint8 * code.2958;
  guint8 * code.2959;
  guint8 * code.2960;
  guint8 * code.2961;
  guint8 * code.2962;
  guint8 * code.2963;
  guint8 * code.2964;
  guint8 * code.2965;
  guint8 * code.2966;
  guint8 * code.2967;
  guint8 * code.2968;
  guint8 * code.2969;
  unsigned char iftmp.2970;
  guint8 * code.2971;
  guint8 * code.2972;
  unsigned char D.28971;
  guint8 * code.2973;
  guint8 * code.2974;
  guint8 * code.2975;
  guint8 * code.2976;
  guint8 * code.2977;
  guint8 * code.2978;
  guint8 * code.2979;
  guint8 * code.2980;
  unsigned char D.28982;
  guint8 * code.2981;
  guint8 * code.2982;
  unsigned char D.28985;
  guint8 * code.2983;
  guint8 * code.2984;
  unsigned char D.28988;
  guint8 * code.2985;
  guint8 * code.2986;
  unsigned char D.28991;
  guint8 * code.2987;
  guint8 * code.2988;
  guint8 * code.2989;
  guint8 * code.2990;
  guint8 * code.2991;
  guint8 * code.2992;
  guint8 * code.2993;
  guint8 * code.2994;
  guint8 * code.2995;
  guint8 * code.2996;
  guint8 * code.2997;
  guint8 * code.2998;
  guint8 * code.2999;
  guint8 * code.3000;
  unsigned char D.29015;
  guint8 * code.3001;
  guint8 * code.3002;
  unsigned char D.29018;
  guint8 * code.3003;
  guint8 * code.3004;
  unsigned char D.29021;
  guint8 * code.3005;
  guint8 * code.3006;
  unsigned char D.29024;
  guint8 * code.3007;
  guint8 * code.3008;
  signed char D.29029;
  unsigned char D.29030;
  guint8 * code.3009;
  guint8 * code.3010;
  signed char D.29035;
  unsigned char D.29036;
  guint8 * code.3011;
  guint8 * code.3012;
  signed char D.29040;
  unsigned char D.29041;
  guint8 * code.3013;
  guint8 * code.3014;
  unsigned char D.29044;
  guint8 * code.3015;
  guint8 * code.3016;
  unsigned char D.29047;
  guint8 * code.3017;
  guint8 * code.3018;
  unsigned char D.29050;
  guint8 * code.3019;
  guint8 * code.3020;
  unsigned char D.29053;
  guint8 * code.3021;
  guint8 * code.3022;
  unsigned char iftmp.3023;
  guint8 * code.3024;
  guint8 * code.3025;
  unsigned char D.29066;
  guint8 * code.3026;
  guint8 * code.3027;
  guint8 * code.3028;
  guint8 * code.3029;
  guint8 * code.3030;
  guint8 * code.3031;
  guint8 * code.3032;
  guint8 * code.3033;
  unsigned char D.29077;
  guint8 * code.3034;
  guint8 * code.3035;
  unsigned char D.29080;
  guint8 * code.3036;
  guint8 * code.3037;
  unsigned char D.29083;
  guint8 * code.3038;
  guint8 * code.3039;
  unsigned char D.29086;
  guint8 * code.3040;
  guint8 * code.3041;
  guint8 * code.3042;
  guint8 * code.3043;
  guint8 * code.3044;
  guint8 * code.3045;
  guint8 * code.3046;
  guint8 * code.3047;
  guint8 * code.3048;
  guint8 * code.3049;
  guint8 * code.3050;
  guint8 * code.3051;
  guint8 * code.3052;
  guint8 * code.3053;
  unsigned char D.29110;
  guint8 * code.3054;
  guint8 * code.3055;
  unsigned char D.29113;
  guint8 * code.3056;
  guint8 * code.3057;
  unsigned char D.29116;
  guint8 * code.3058;
  guint8 * code.3059;
  unsigned char D.29119;
  guint8 * code.3060;
  guint8 * code.3061;
  signed char D.29124;
  unsigned char D.29125;
  guint8 * code.3062;
  guint8 * code.3063;
  signed char D.29130;
  unsigned char D.29131;
  guint8 * code.3064;
  guint8 * code.3065;
  signed char D.29135;
  unsigned char D.29136;
  guint8 * code.3066;
  guint8 * code.3067;
  unsigned char D.29139;
  guint8 * code.3068;
  guint8 * code.3069;
  unsigned char D.29142;
  guint8 * code.3070;
  guint8 * code.3071;
  unsigned char D.29145;
  guint8 * code.3072;
  guint8 * code.3073;
  unsigned char D.29148;
  guint8 * code.3074;
  guint8 * code.3075;
  guint8 * code.3076;
  guint8 * code.3077;
  unsigned char D.29155;
  guint8 * code.3078;
  guint8 * code.3079;
  guint8 * code.3080;
  guint8 * code.3081;
  unsigned char iftmp.3082;
  guint8 * code.3083;
  guint8 * code.3084;
  unsigned char D.29170;
  guint8 * code.3085;
  guint8 * code.3086;
  guint8 * code.3087;
  guint8 * code.3088;
  guint8 * code.3089;
  guint8 * code.3090;
  guint8 * code.3091;
  guint8 * code.3092;
  unsigned char D.29181;
  guint8 * code.3093;
  guint8 * code.3094;
  unsigned char D.29184;
  guint8 * code.3095;
  guint8 * code.3096;
  unsigned char D.29187;
  guint8 * code.3097;
  guint8 * code.3098;
  unsigned char D.29190;
  guint8 * code.3099;
  guint8 * code.3100;
  guint8 * code.3101;
  guint8 * code.3102;
  guint8 * code.3103;
  guint8 * code.3104;
  guint8 * code.3105;
  guint8 * code.3106;
  guint8 * code.3107;
  guint8 * code.3108;
  guint8 * code.3109;
  guint8 * code.3110;
  guint8 * code.3111;
  guint8 * code.3112;
  unsigned char D.29214;
  guint8 * code.3113;
  guint8 * code.3114;
  unsigned char D.29217;
  guint8 * code.3115;
  guint8 * code.3116;
  unsigned char D.29220;
  guint8 * code.3117;
  guint8 * code.3118;
  unsigned char D.29223;
  guint8 * code.3119;
  guint8 * code.3120;
  guint8 * code.3121;
  guint8 * code.3122;
  guint8 * code.3123;
  guint8 * code.3124;
  guint8 * code.3125;
  guint8 * code.3126;
  unsigned char D.29237;
  guint8 * code.3127;
  guint8 * code.3128;
  unsigned char D.29240;
  guint8 * code.3129;
  guint8 * code.3130;
  unsigned char D.29243;
  guint8 * code.3131;
  guint8 * code.3132;
  unsigned char D.29246;
  guint8 * code.3133;
  guint8 * code.3134;
  guint8 * code.3135;
  guint8 * code.3136;
  unsigned char D.29255;
  guint8 * code.3137;
  guint8 * code.3138;
  guint8 * code.3139;
  guint8 * code.3140;
  guint8 * code.3141;
  guint8 * code.3142;
  guint8 * code.3143;
  guint8 * code.3144;
  unsigned char D.29266;
  guint8 * code.3145;
  guint8 * code.3146;
  unsigned char D.29269;
  guint8 * code.3147;
  guint8 * code.3148;
  unsigned char D.29272;
  guint8 * code.3149;
  guint8 * code.3150;
  unsigned char D.29275;
  guint8 * code.3151;
  guint8 * code.3152;
  guint8 * code.3153;
  guint8 * code.3154;
  guint8 * code.3155;
  guint8 * code.3156;
  guint8 * code.3157;
  guint8 * code.3158;
  guint8 * code.3159;
  guint8 * code.3160;
  guint8 * code.3161;
  guint8 * code.3162;
  guint8 * code.3163;
  guint8 * code.3164;
  unsigned char D.29299;
  guint8 * code.3165;
  guint8 * code.3166;
  unsigned char D.29302;
  guint8 * code.3167;
  guint8 * code.3168;
  unsigned char D.29305;
  guint8 * code.3169;
  guint8 * code.3170;
  unsigned char D.29308;
  guint8 * code.3171;
  guint8 * code.3172;
  guint8 * code.3173;
  guint8 * code.3174;
  guint8 * code.3175;
  guint8 * code.3176;
  guint8 * code.3177;
  guint8 * code.3178;
  unsigned char D.29322;
  guint8 * code.3179;
  guint8 * code.3180;
  unsigned char D.29325;
  guint8 * code.3181;
  guint8 * code.3182;
  unsigned char D.29328;
  guint8 * code.3183;
  guint8 * code.3184;
  unsigned char D.29331;
  guint8 * code.3185;
  guint8 * code.3186;
  guint8 * code.3187;
  guint8 * code.3188;
  unsigned char D.29340;
  guint8 * code.3189;
  guint8 * code.3190;
  guint8 * code.3191;
  guint8 * code.3192;
  guint8 * code.3193;
  guint8 * code.3194;
  guint8 * code.3195;
  guint8 * code.3196;
  unsigned char D.29351;
  guint8 * code.3197;
  guint8 * code.3198;
  unsigned char D.29354;
  guint8 * code.3199;
  guint8 * code.3200;
  unsigned char D.29357;
  guint8 * code.3201;
  guint8 * code.3202;
  unsigned char D.29360;
  guint8 * code.3203;
  guint8 * code.3204;
  guint8 * code.3205;
  guint8 * code.3206;
  guint8 * code.3207;
  guint8 * code.3208;
  guint8 * code.3209;
  guint8 * code.3210;
  guint8 * code.3211;
  guint8 * code.3212;
  guint8 * code.3213;
  guint8 * code.3214;
  guint8 * code.3215;
  guint8 * code.3216;
  unsigned char D.29384;
  guint8 * code.3217;
  guint8 * code.3218;
  unsigned char D.29387;
  guint8 * code.3219;
  guint8 * code.3220;
  unsigned char D.29390;
  guint8 * code.3221;
  guint8 * code.3222;
  unsigned char D.29393;
  guint8 * code.3223;
  guint8 * code.3224;
  guint8 * code.3225;
  guint8 * code.3226;
  guint8 * code.3227;
  guint8 * code.3228;
  guint8 * code.3229;
  guint8 * code.3230;
  unsigned char D.29407;
  guint8 * code.3231;
  guint8 * code.3232;
  unsigned char D.29410;
  guint8 * code.3233;
  guint8 * code.3234;
  unsigned char D.29413;
  guint8 * code.3235;
  guint8 * code.3236;
  unsigned char D.29416;
  guint8 * code.3237;
  guint8 * code.3238;
  guint8 * code.3239;
  guint8 * code.3240;
  unsigned char D.29425;
  guint8 * code.3241;
  guint8 * code.3242;
  guint8 * code.3243;
  guint8 * code.3244;
  guint8 * code.3245;
  guint8 * code.3246;
  guint8 * code.3247;
  guint8 * code.3248;
  unsigned char D.29436;
  guint8 * code.3249;
  guint8 * code.3250;
  unsigned char D.29439;
  guint8 * code.3251;
  guint8 * code.3252;
  unsigned char D.29442;
  guint8 * code.3253;
  guint8 * code.3254;
  unsigned char D.29445;
  guint8 * code.3255;
  guint8 * code.3256;
  guint8 * code.3257;
  guint8 * code.3258;
  guint8 * code.3259;
  guint8 * code.3260;
  guint8 * code.3261;
  guint8 * code.3262;
  guint8 * code.3263;
  guint8 * code.3264;
  guint8 * code.3265;
  guint8 * code.3266;
  guint8 * code.3267;
  guint8 * code.3268;
  unsigned char D.29469;
  guint8 * code.3269;
  guint8 * code.3270;
  unsigned char D.29472;
  guint8 * code.3271;
  guint8 * code.3272;
  unsigned char D.29475;
  guint8 * code.3273;
  guint8 * code.3274;
  unsigned char D.29478;
  guint8 * code.3275;
  guint8 * code.3276;
  guint8 * code.3277;
  guint8 * code.3278;
  guint8 * code.3279;
  guint8 * code.3280;
  guint8 * code.3281;
  guint8 * code.3282;
  unsigned char D.29492;
  guint8 * code.3283;
  guint8 * code.3284;
  unsigned char D.29495;
  guint8 * code.3285;
  guint8 * code.3286;
  unsigned char D.29498;
  guint8 * code.3287;
  guint8 * code.3288;
  unsigned char D.29501;
  guint8 * code.3289;
  guint8 * code.3290;
  guint8 * code.3291;
  guint8 * code.3292;
  unsigned char D.29510;
  guint8 * code.3293;
  guint8 * code.3294;
  guint8 * code.3295;
  guint8 * code.3296;
  guint8 * code.3297;
  guint8 * code.3298;
  guint8 * code.3299;
  guint8 * code.3300;
  unsigned char D.29521;
  guint8 * code.3301;
  guint8 * code.3302;
  unsigned char D.29524;
  guint8 * code.3303;
  guint8 * code.3304;
  unsigned char D.29527;
  guint8 * code.3305;
  guint8 * code.3306;
  unsigned char D.29530;
  guint8 * code.3307;
  guint8 * code.3308;
  guint8 * code.3309;
  guint8 * code.3310;
  guint8 * code.3311;
  guint8 * code.3312;
  guint8 * code.3313;
  guint8 * code.3314;
  guint8 * code.3315;
  guint8 * code.3316;
  guint8 * code.3317;
  guint8 * code.3318;
  guint8 * code.3319;
  guint8 * code.3320;
  unsigned char D.29554;
  guint8 * code.3321;
  guint8 * code.3322;
  unsigned char D.29557;
  guint8 * code.3323;
  guint8 * code.3324;
  unsigned char D.29560;
  guint8 * code.3325;
  guint8 * code.3326;
  unsigned char D.29563;
  guint8 * code.3327;
  guint8 * code.3328;
  guint8 * code.3329;
  guint8 * code.3330;
  guint8 * code.3331;
  guint8 * code.3332;
  guint8 * code.3333;
  guint8 * code.3334;
  unsigned char D.29577;
  guint8 * code.3335;
  guint8 * code.3336;
  unsigned char D.29580;
  guint8 * code.3337;
  guint8 * code.3338;
  unsigned char D.29583;
  guint8 * code.3339;
  guint8 * code.3340;
  unsigned char D.29586;
  guint8 * code.3341;
  guint8 * code.3342;
  guint8 * code.3343;
  guint8 * code.3344;
  unsigned char D.29595;
  guint8 * code.3345;
  guint8 * code.3346;
  guint8 * code.3347;
  guint8 * code.3348;
  guint8 * code.3349;
  guint8 * code.3350;
  guint8 * code.3351;
  guint8 * code.3352;
  unsigned char D.29606;
  guint8 * code.3353;
  guint8 * code.3354;
  unsigned char D.29609;
  guint8 * code.3355;
  guint8 * code.3356;
  unsigned char D.29612;
  guint8 * code.3357;
  guint8 * code.3358;
  unsigned char D.29615;
  guint8 * code.3359;
  guint8 * code.3360;
  guint8 * code.3361;
  guint8 * code.3362;
  guint8 * code.3363;
  guint8 * code.3364;
  guint8 * code.3365;
  guint8 * code.3366;
  guint8 * code.3367;
  guint8 * code.3368;
  guint8 * code.3369;
  guint8 * code.3370;
  guint8 * code.3371;
  guint8 * code.3372;
  unsigned char D.29639;
  guint8 * code.3373;
  guint8 * code.3374;
  unsigned char D.29642;
  guint8 * code.3375;
  guint8 * code.3376;
  unsigned char D.29645;
  guint8 * code.3377;
  guint8 * code.3378;
  unsigned char D.29648;
  guint8 * code.3379;
  guint8 * code.3380;
  guint8 * code.3381;
  guint8 * code.3382;
  guint8 * code.3383;
  guint8 * code.3384;
  guint8 * code.3385;
  guint8 * code.3386;
  unsigned char D.29662;
  guint8 * code.3387;
  guint8 * code.3388;
  unsigned char D.29665;
  guint8 * code.3389;
  guint8 * code.3390;
  unsigned char D.29668;
  guint8 * code.3391;
  guint8 * code.3392;
  unsigned char D.29671;
  guint8 * code.3393;
  guint8 * code.3394;
  guint8 * code.3395;
  guint8 * code.3396;
  unsigned char D.29680;
  guint8 * code.3397;
  guint8 * code.3398;
  guint8 * code.3399;
  guint8 * code.3400;
  guint8 * code.3401;
  guint8 * code.3402;
  guint8 * code.3403;
  guint8 * code.3404;
  unsigned char D.29691;
  guint8 * code.3405;
  guint8 * code.3406;
  unsigned char D.29694;
  guint8 * code.3407;
  guint8 * code.3408;
  unsigned char D.29697;
  guint8 * code.3409;
  guint8 * code.3410;
  unsigned char D.29700;
  guint8 * code.3411;
  guint8 * code.3412;
  guint8 * code.3413;
  guint8 * code.3414;
  guint8 * code.3415;
  guint8 * code.3416;
  guint8 * code.3417;
  guint8 * code.3418;
  guint8 * code.3419;
  guint8 * code.3420;
  guint8 * code.3421;
  guint8 * code.3422;
  guint8 * code.3423;
  guint8 * code.3424;
  unsigned char D.29724;
  guint8 * code.3425;
  guint8 * code.3426;
  unsigned char D.29727;
  guint8 * code.3427;
  guint8 * code.3428;
  unsigned char D.29730;
  guint8 * code.3429;
  guint8 * code.3430;
  unsigned char D.29733;
  guint8 * code.3431;
  guint8 * code.3432;
  guint8 * code.3433;
  guint8 * code.3434;
  guint8 * code.3435;
  guint8 * code.3436;
  guint8 * code.3437;
  guint8 * code.3438;
  unsigned char D.29747;
  guint8 * code.3439;
  guint8 * code.3440;
  unsigned char D.29750;
  guint8 * code.3441;
  guint8 * code.3442;
  unsigned char D.29753;
  guint8 * code.3443;
  guint8 * code.3444;
  unsigned char D.29756;
  guint8 * code.3445;
  guint8 * code.3446;
  guint8 * code.3447;
  guint8 * code.3448;
  unsigned char D.29765;
  guint8 * code.3449;
  guint8 * code.3450;
  guint8 * code.3451;
  guint8 * code.3452;
  guint8 * code.3453;
  guint8 * code.3454;
  guint8 * code.3455;
  guint8 * code.3456;
  unsigned char D.29776;
  guint8 * code.3457;
  guint8 * code.3458;
  unsigned char D.29779;
  guint8 * code.3459;
  guint8 * code.3460;
  unsigned char D.29782;
  guint8 * code.3461;
  guint8 * code.3462;
  unsigned char D.29785;
  guint8 * code.3463;
  guint8 * code.3464;
  guint8 * code.3465;
  guint8 * code.3466;
  guint8 * code.3467;
  guint8 * code.3468;
  guint8 * code.3469;
  guint8 * code.3470;
  guint8 * code.3471;
  guint8 * code.3472;
  guint8 * code.3473;
  guint8 * code.3474;
  guint8 * code.3475;
  guint8 * code.3476;
  unsigned char D.29809;
  guint8 * code.3477;
  guint8 * code.3478;
  unsigned char D.29812;
  guint8 * code.3479;
  guint8 * code.3480;
  unsigned char D.29815;
  guint8 * code.3481;
  guint8 * code.3482;
  unsigned char D.29818;
  guint8 * code.3483;
  guint8 * code.3484;
  guint8 * code.3485;
  guint8 * code.3486;
  guint8 * code.3487;
  guint8 * code.3488;
  guint8 * code.3489;
  guint8 * code.3490;
  unsigned char D.29832;
  guint8 * code.3491;
  guint8 * code.3492;
  unsigned char D.29835;
  guint8 * code.3493;
  guint8 * code.3494;
  unsigned char D.29838;
  guint8 * code.3495;
  guint8 * code.3496;
  unsigned char D.29841;
  guint8 * code.3497;
  guint8 * code.3498;
  unsigned char D.29846;
  guint8 * code.3499;
  guint8 * code.3500;
  guint8 * code.3501;
  guint8 * code.3502;
  guint8 * code.3503;
  guint8 * code.3504;
  unsigned char D.29855;
  guint8 * code.3505;
  guint8 * code.3506;
  unsigned char D.29858;
  guint8 * code.3507;
  guint8 * code.3508;
  unsigned char D.29861;
  guint8 * code.3509;
  guint8 * code.3510;
  unsigned char D.29864;
  guint8 * code.3511;
  guint8 * code.3512;
  guint8 * code.3513;
  guint8 * code.3514;
  guint8 * code.3515;
  guint8 * code.3516;
  guint8 * code.3517;
  guint8 * code.3518;
  guint8 * code.3519;
  guint8 * code.3520;
  guint8 * code.3521;
  guint8 * code.3522;
  guint8 * code.3523;
  guint8 * code.3524;
  unsigned char D.29888;
  guint8 * code.3525;
  guint8 * code.3526;
  unsigned char D.29891;
  guint8 * code.3527;
  guint8 * code.3528;
  unsigned char D.29894;
  guint8 * code.3529;
  guint8 * code.3530;
  unsigned char D.29897;
  guint8 * code.3531;
  guint8 * code.3532;
  signed char D.29902;
  unsigned char D.29903;
  guint8 * code.3533;
  guint8 * code.3534;
  signed char D.29908;
  unsigned char D.29909;
  guint8 * code.3535;
  guint8 * code.3536;
  signed char D.29913;
  unsigned char D.29914;
  guint8 * code.3537;
  guint8 * code.3538;
  unsigned char D.29917;
  guint8 * code.3539;
  guint8 * code.3540;
  unsigned char D.29920;
  guint8 * code.3541;
  guint8 * code.3542;
  unsigned char D.29923;
  guint8 * code.3543;
  guint8 * code.3544;
  unsigned char D.29926;
  long int code.3545;
  long int start.3546;
  long int D.29929;
  _Bool D.29930;
  long int D.29931;
  long int D.29932;
  static guint8 * saved = 0B;
  guint8 * code;
  guint8 * start;
  int cont_reg;
  const guint kMaxCodeSize;
  static const char __PRETTY_FUNCTION__[27] = "mono_tasklets_arch_restore";

  try
    {
      cont_reg = 9;
      kMaxCodeSize = 64;
      saved.2877 = saved;
      if (saved.2877 != 0B) goto <D.28800>; else goto <D.28801>;
      <D.28800>:
      saved.2877 = saved;
      D.28802 = (void (*MonoContinuationRestore) (struct MonoContinuation *, int, struct MonoLMF * *)) saved.2877;
      return D.28802;
      <D.28801>:
      kMaxCodeSize.2878 = (int) kMaxCodeSize;
      start.2879 = mono_global_codeman_reserve (kMaxCodeSize.2878);
      start = start.2879;
      start.2880 = start;
      code = start.2880;
      if (0 != 0) goto <D.28806>; else goto <D.28807>;
      <D.28806>:
      code.2881 = code;
      code.2882 = code.2881;
      code.2883 = code.2882 + 1;
      code = code.2883;
      *code.2882 = 102;
      <D.28807>:
      {
        unsigned char _amd64_rex_bits;

        if (cont_reg > 7) goto <D.28812>; else goto <D.28813>;
        <D.28812>:
        iftmp.2884 = 12;
        goto <D.28814>;
        <D.28813>:
        iftmp.2884 = 8;
        <D.28814>:
        _amd64_rex_bits = iftmp.2884;
        if (_amd64_rex_bits != 0) goto <D.28815>; else goto <D.28816>;
        <D.28815>:
        code.2881 = code;
        code.2885 = code.2881;
        code.2886 = code.2885 + 1;
        code = code.2886;
        D.28819 = _amd64_rex_bits | 64;
        *code.2885 = D.28819;
        <D.28816>:
      }
      switch (8) <default: <D.23514>, case 1: <D.23509>, case 2: <D.23511>, case 4: <D.23512>, case 8: <D.23513>>
      <D.23509>:
      code.2881 = code;
      code.2887 = code.2881;
      code.2888 = code.2887 + 1;
      code = code.2888;
      *code.2887 = 138;
      goto <D.23510>;
      <D.23511>:
      <D.23512>:
      <D.23513>:
      code.2881 = code;
      code.2889 = code.2881;
      code.2890 = code.2889 + 1;
      code = code.2890;
      *code.2889 = 139;
      goto <D.23510>;
      <D.23514>:
      __assert_fail ("0", "exceptions-amd64.c", 1420, &__PRETTY_FUNCTION__);
      <D.23510>:
      code.2881 = code;
      code.2891 = code.2881;
      code.2892 = code.2891 + 1;
      code = code.2892;
      D.28826 = cont_reg & 7;
      D.28827 = D.28826 << 3;
      D.28828 = (signed char) D.28827;
      D.28829 = D.28828 | -57;
      D.28830 = (unsigned char) D.28829;
      *code.2891 = D.28830;
      if (0 != 0) goto <D.28831>; else goto <D.28832>;
      <D.28831>:
      code.2881 = code;
      code.2893 = code.2881;
      code.2894 = code.2893 + 1;
      code = code.2894;
      *code.2893 = 102;
      <D.28832>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28835>; else goto <D.28836>;
        <D.28835>:
        code.2881 = code;
        code.2895 = code.2881;
        code.2896 = code.2895 + 1;
        code = code.2896;
        D.28839 = _amd64_rex_bits | 64;
        *code.2895 = D.28839;
        <D.28836>:
      }
      switch (8) <default: <D.23522>, case 1: <D.23517>, case 2: <D.23519>, case 4: <D.23520>, case 8: <D.23521>>
      <D.23517>:
      code.2881 = code;
      code.2897 = code.2881;
      code.2898 = code.2897 + 1;
      code = code.2898;
      *code.2897 = 138;
      goto <D.23518>;
      <D.23519>:
      <D.23520>:
      <D.23521>:
      code.2881 = code;
      code.2899 = code.2881;
      code.2900 = code.2899 + 1;
      code = code.2900;
      *code.2899 = 139;
      goto <D.23518>;
      <D.23522>:
      __assert_fail ("0", "exceptions-amd64.c", 1421, &__PRETTY_FUNCTION__);
      <D.23518>:
      code.2881 = code;
      code.2901 = code.2881;
      code.2902 = code.2901 + 1;
      code = code.2902;
      *code.2901 = 198;
      if (0 != 0) goto <D.28846>; else goto <D.28847>;
      <D.28846>:
      code.2881 = code;
      code.2903 = code.2881;
      code.2904 = code.2903 + 1;
      code = code.2904;
      *code.2903 = 102;
      <D.28847>:
      {
        unsigned char _amd64_rex_bits;

        D.28850 = cont_reg > 7;
        _amd64_rex_bits = (unsigned char) D.28850;
        if (_amd64_rex_bits != 0) goto <D.28851>; else goto <D.28852>;
        <D.28851>:
        code.2881 = code;
        code.2905 = code.2881;
        code.2906 = code.2905 + 1;
        code = code.2906;
        D.28855 = _amd64_rex_bits | 64;
        *code.2905 = D.28855;
        <D.28852>:
      }
      switch (4) <default: <D.23529>, case 1: <D.23524>, case 2: <D.23526>, case 4: <D.23527>, case 8: <D.23528>>
      <D.23524>:
      code.2881 = code;
      code.2907 = code.2881;
      code.2908 = code.2907 + 1;
      code = code.2908;
      *code.2907 = 138;
      goto <D.23525>;
      <D.23526>:
      <D.23527>:
      <D.23528>:
      code.2881 = code;
      code.2909 = code.2881;
      code.2910 = code.2909 + 1;
      code = code.2910;
      *code.2909 = 139;
      goto <D.23525>;
      <D.23529>:
      __assert_fail ("0", "exceptions-amd64.c", 1423, &__PRETTY_FUNCTION__);
      <D.23525>:
      if (cont_reg == 16) goto <D.28860>; else goto <D.28861>;
      <D.28860>:
      code.2881 = code;
      code.2911 = code.2881;
      code.2912 = code.2911 + 1;
      code = code.2912;
      *code.2911 = 13;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 52;
            code.2881 = code;
            code.2913 = code.2881;
            code.2914 = code.2913 + 1;
            code = code.2914;
            D.28866 = imb.b[0];
            *code.2913 = D.28866;
            code.2881 = code;
            code.2915 = code.2881;
            code.2916 = code.2915 + 1;
            code = code.2916;
            D.28869 = imb.b[1];
            *code.2915 = D.28869;
            code.2881 = code;
            code.2917 = code.2881;
            code.2918 = code.2917 + 1;
            code = code.2918;
            D.28872 = imb.b[2];
            *code.2917 = D.28872;
            code.2881 = code;
            code.2919 = code.2881;
            code.2920 = code.2919 + 1;
            code = code.2920;
            D.28875 = imb.b[3];
            *code.2919 = D.28875;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28876>;
      <D.28861>:
      D.28826 = cont_reg & 7;
      if (D.28826 == 4) goto <D.28877>; else goto <D.28878>;
      <D.28877>:
      if (0 != 0) goto <D.28879>; else goto <D.28880>;
      <D.28879>:
      code.2881 = code;
      code.2921 = code.2881;
      code.2922 = code.2921 + 1;
      code = code.2922;
      *code.2921 = 12;
      code.2881 = code;
      code.2923 = code.2881;
      code.2924 = code.2923 + 1;
      code = code.2924;
      *code.2923 = 36;
      goto <D.28885>;
      <D.28880>:
      if (1 != 0) goto <D.28886>; else goto <D.28887>;
      <D.28886>:
      code.2881 = code;
      code.2925 = code.2881;
      code.2926 = code.2925 + 1;
      code = code.2926;
      *code.2925 = 76;
      code.2881 = code;
      code.2927 = code.2881;
      code.2928 = code.2927 + 1;
      code = code.2928;
      *code.2927 = 36;
      code.2881 = code;
      *code.2881 = 52;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.28893>;
      <D.28887>:
      code.2881 = code;
      code.2930 = code.2881;
      code.2931 = code.2930 + 1;
      code = code.2931;
      *code.2930 = 140;
      code.2881 = code;
      code.2932 = code.2881;
      code.2933 = code.2932 + 1;
      code = code.2933;
      *code.2932 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 52;
            code.2881 = code;
            code.2934 = code.2881;
            code.2935 = code.2934 + 1;
            code = code.2935;
            D.28900 = imb.b[0];
            *code.2934 = D.28900;
            code.2881 = code;
            code.2936 = code.2881;
            code.2937 = code.2936 + 1;
            code = code.2937;
            D.28903 = imb.b[1];
            *code.2936 = D.28903;
            code.2881 = code;
            code.2938 = code.2881;
            code.2939 = code.2938 + 1;
            code = code.2939;
            D.28906 = imb.b[2];
            *code.2938 = D.28906;
            code.2881 = code;
            code.2940 = code.2881;
            code.2941 = code.2940 + 1;
            code = code.2941;
            D.28909 = imb.b[3];
            *code.2940 = D.28909;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28893>:
      <D.28885>:
      goto <D.23532>;
      <D.28878>:
      if (0 != 0) goto <D.28910>; else goto <D.28911>;
      <D.28910>:
      code.2881 = code;
      code.2942 = code.2881;
      code.2943 = code.2942 + 1;
      code = code.2943;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28916 = D.28915 | 8;
      D.28917 = (unsigned char) D.28916;
      *code.2942 = D.28917;
      goto <D.23532>;
      <D.28911>:
      if (1 != 0) goto <D.28918>; else goto <D.28919>;
      <D.28918>:
      code.2881 = code;
      code.2944 = code.2881;
      code.2945 = code.2944 + 1;
      code = code.2945;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28922 = D.28915 | 72;
      D.28923 = (unsigned char) D.28922;
      *code.2944 = D.28923;
      code.2881 = code;
      *code.2881 = 52;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.28924>;
      <D.28919>:
      code.2881 = code;
      code.2946 = code.2881;
      code.2947 = code.2946 + 1;
      code = code.2947;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28927 = D.28915 | -120;
      D.28928 = (unsigned char) D.28927;
      *code.2946 = D.28928;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 52;
            code.2881 = code;
            code.2948 = code.2881;
            code.2949 = code.2948 + 1;
            code = code.2949;
            D.28931 = imb.b[0];
            *code.2948 = D.28931;
            code.2881 = code;
            code.2950 = code.2881;
            code.2951 = code.2950 + 1;
            code = code.2951;
            D.28934 = imb.b[1];
            *code.2950 = D.28934;
            code.2881 = code;
            code.2952 = code.2881;
            code.2953 = code.2952 + 1;
            code = code.2953;
            D.28937 = imb.b[2];
            *code.2952 = D.28937;
            code.2881 = code;
            code.2954 = code.2881;
            code.2955 = code.2954 + 1;
            code = code.2955;
            D.28940 = imb.b[3];
            *code.2954 = D.28940;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.28924>:
      <D.23532>:
      <D.28876>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.28941>; else goto <D.28942>;
        <D.28941>:
        code.2881 = code;
        code.2956 = code.2881;
        code.2957 = code.2956 + 1;
        code = code.2957;
        D.28945 = _amd64_rex_bits | 64;
        *code.2956 = D.28945;
        <D.28942>:
      }
      if (0 != 0) goto <D.28946>; else goto <D.28947>;
      <D.28946>:
      code.2881 = code;
      code.2958 = code.2881;
      code.2959 = code.2958 + 1;
      code = code.2959;
      *code.2958 = 209;
      code.2881 = code;
      code.2960 = code.2881;
      code.2961 = code.2960 + 1;
      code = code.2961;
      *code.2960 = 233;
      goto <D.28952>;
      <D.28947>:
      code.2881 = code;
      code.2962 = code.2881;
      code.2963 = code.2962 + 1;
      code = code.2963;
      *code.2962 = 193;
      code.2881 = code;
      code.2964 = code.2881;
      code.2965 = code.2964 + 1;
      code = code.2965;
      *code.2964 = 233;
      code.2881 = code;
      *code.2881 = 3;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      <D.28952>:
      code.2881 = code;
      code.2966 = code.2881;
      code.2967 = code.2966 + 1;
      code = code.2967;
      *code.2966 = 252;
      if (0 != 0) goto <D.28959>; else goto <D.28960>;
      <D.28959>:
      code.2881 = code;
      code.2968 = code.2881;
      code.2969 = code.2968 + 1;
      code = code.2969;
      *code.2968 = 102;
      <D.28960>:
      {
        unsigned char _amd64_rex_bits;

        if (cont_reg > 7) goto <D.28964>; else goto <D.28965>;
        <D.28964>:
        iftmp.2970 = 9;
        goto <D.28966>;
        <D.28965>:
        iftmp.2970 = 8;
        <D.28966>:
        _amd64_rex_bits = iftmp.2970;
        if (_amd64_rex_bits != 0) goto <D.28967>; else goto <D.28968>;
        <D.28967>:
        code.2881 = code;
        code.2971 = code.2881;
        code.2972 = code.2971 + 1;
        code = code.2972;
        D.28971 = _amd64_rex_bits | 64;
        *code.2971 = D.28971;
        <D.28968>:
      }
      switch (8) <default: <D.23541>, case 1: <D.23536>, case 2: <D.23538>, case 4: <D.23539>, case 8: <D.23540>>
      <D.23536>:
      code.2881 = code;
      code.2973 = code.2881;
      code.2974 = code.2973 + 1;
      code = code.2974;
      *code.2973 = 138;
      goto <D.23537>;
      <D.23538>:
      <D.23539>:
      <D.23540>:
      code.2881 = code;
      code.2975 = code.2881;
      code.2976 = code.2975 + 1;
      code = code.2976;
      *code.2975 = 139;
      goto <D.23537>;
      <D.23541>:
      __assert_fail ("0", "exceptions-amd64.c", 1426, &__PRETTY_FUNCTION__);
      <D.23537>:
      if (cont_reg == 16) goto <D.28976>; else goto <D.28977>;
      <D.28976>:
      code.2881 = code;
      code.2977 = code.2881;
      code.2978 = code.2977 + 1;
      code = code.2978;
      *code.2977 = 53;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.2979 = code.2881;
            code.2980 = code.2979 + 1;
            code = code.2980;
            D.28982 = imb.b[0];
            *code.2979 = D.28982;
            code.2881 = code;
            code.2981 = code.2881;
            code.2982 = code.2981 + 1;
            code = code.2982;
            D.28985 = imb.b[1];
            *code.2981 = D.28985;
            code.2881 = code;
            code.2983 = code.2881;
            code.2984 = code.2983 + 1;
            code = code.2984;
            D.28988 = imb.b[2];
            *code.2983 = D.28988;
            code.2881 = code;
            code.2985 = code.2881;
            code.2986 = code.2985 + 1;
            code = code.2986;
            D.28991 = imb.b[3];
            *code.2985 = D.28991;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.28992>;
      <D.28977>:
      D.28826 = cont_reg & 7;
      if (D.28826 == 4) goto <D.28993>; else goto <D.28994>;
      <D.28993>:
      if (0 != 0) goto <D.28995>; else goto <D.28996>;
      <D.28995>:
      code.2881 = code;
      code.2987 = code.2881;
      code.2988 = code.2987 + 1;
      code = code.2988;
      *code.2987 = 52;
      code.2881 = code;
      code.2989 = code.2881;
      code.2990 = code.2989 + 1;
      code = code.2990;
      *code.2989 = 36;
      goto <D.29001>;
      <D.28996>:
      if (1 != 0) goto <D.29002>; else goto <D.29003>;
      <D.29002>:
      code.2881 = code;
      code.2991 = code.2881;
      code.2992 = code.2991 + 1;
      code = code.2992;
      *code.2991 = 116;
      code.2881 = code;
      code.2993 = code.2881;
      code.2994 = code.2993 + 1;
      code = code.2994;
      *code.2993 = 36;
      code.2881 = code;
      *code.2881 = 56;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29008>;
      <D.29003>:
      code.2881 = code;
      code.2995 = code.2881;
      code.2996 = code.2995 + 1;
      code = code.2996;
      *code.2995 = 180;
      code.2881 = code;
      code.2997 = code.2881;
      code.2998 = code.2997 + 1;
      code = code.2998;
      *code.2997 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.2999 = code.2881;
            code.3000 = code.2999 + 1;
            code = code.3000;
            D.29015 = imb.b[0];
            *code.2999 = D.29015;
            code.2881 = code;
            code.3001 = code.2881;
            code.3002 = code.3001 + 1;
            code = code.3002;
            D.29018 = imb.b[1];
            *code.3001 = D.29018;
            code.2881 = code;
            code.3003 = code.2881;
            code.3004 = code.3003 + 1;
            code = code.3004;
            D.29021 = imb.b[2];
            *code.3003 = D.29021;
            code.2881 = code;
            code.3005 = code.2881;
            code.3006 = code.3005 + 1;
            code = code.3006;
            D.29024 = imb.b[3];
            *code.3005 = D.29024;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29008>:
      <D.29001>:
      goto <D.23544>;
      <D.28994>:
      if (0 != 0) goto <D.29025>; else goto <D.29026>;
      <D.29025>:
      code.2881 = code;
      code.3007 = code.2881;
      code.3008 = code.3007 + 1;
      code = code.3008;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29029 = D.28915 | 48;
      D.29030 = (unsigned char) D.29029;
      *code.3007 = D.29030;
      goto <D.23544>;
      <D.29026>:
      if (1 != 0) goto <D.29031>; else goto <D.29032>;
      <D.29031>:
      code.2881 = code;
      code.3009 = code.2881;
      code.3010 = code.3009 + 1;
      code = code.3010;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29035 = D.28915 | 112;
      D.29036 = (unsigned char) D.29035;
      *code.3009 = D.29036;
      code.2881 = code;
      *code.2881 = 56;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29037>;
      <D.29032>:
      code.2881 = code;
      code.3011 = code.2881;
      code.3012 = code.3011 + 1;
      code = code.3012;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29040 = D.28915 | -80;
      D.29041 = (unsigned char) D.29040;
      *code.3011 = D.29041;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.3013 = code.2881;
            code.3014 = code.3013 + 1;
            code = code.3014;
            D.29044 = imb.b[0];
            *code.3013 = D.29044;
            code.2881 = code;
            code.3015 = code.2881;
            code.3016 = code.3015 + 1;
            code = code.3016;
            D.29047 = imb.b[1];
            *code.3015 = D.29047;
            code.2881 = code;
            code.3017 = code.2881;
            code.3018 = code.3017 + 1;
            code = code.3018;
            D.29050 = imb.b[2];
            *code.3017 = D.29050;
            code.2881 = code;
            code.3019 = code.2881;
            code.3020 = code.3019 + 1;
            code = code.3020;
            D.29053 = imb.b[3];
            *code.3019 = D.29053;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29037>:
      <D.23544>:
      <D.28992>:
      if (0 != 0) goto <D.29054>; else goto <D.29055>;
      <D.29054>:
      code.2881 = code;
      code.3021 = code.2881;
      code.3022 = code.3021 + 1;
      code = code.3022;
      *code.3021 = 102;
      <D.29055>:
      {
        unsigned char _amd64_rex_bits;

        if (cont_reg > 7) goto <D.29059>; else goto <D.29060>;
        <D.29059>:
        iftmp.3023 = 9;
        goto <D.29061>;
        <D.29060>:
        iftmp.3023 = 8;
        <D.29061>:
        _amd64_rex_bits = iftmp.3023;
        if (_amd64_rex_bits != 0) goto <D.29062>; else goto <D.29063>;
        <D.29062>:
        code.2881 = code;
        code.3024 = code.2881;
        code.3025 = code.3024 + 1;
        code = code.3025;
        D.29066 = _amd64_rex_bits | 64;
        *code.3024 = D.29066;
        <D.29063>:
      }
      switch (8) <default: <D.23552>, case 1: <D.23547>, case 2: <D.23549>, case 4: <D.23550>, case 8: <D.23551>>
      <D.23547>:
      code.2881 = code;
      code.3026 = code.2881;
      code.3027 = code.3026 + 1;
      code = code.3027;
      *code.3026 = 138;
      goto <D.23548>;
      <D.23549>:
      <D.23550>:
      <D.23551>:
      code.2881 = code;
      code.3028 = code.2881;
      code.3029 = code.3028 + 1;
      code = code.3029;
      *code.3028 = 139;
      goto <D.23548>;
      <D.23552>:
      __assert_fail ("0", "exceptions-amd64.c", 1427, &__PRETTY_FUNCTION__);
      <D.23548>:
      if (cont_reg == 16) goto <D.29071>; else goto <D.29072>;
      <D.29071>:
      code.2881 = code;
      code.3030 = code.2881;
      code.3031 = code.3030 + 1;
      code = code.3031;
      *code.3030 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3032 = code.2881;
            code.3033 = code.3032 + 1;
            code = code.3033;
            D.29077 = imb.b[0];
            *code.3032 = D.29077;
            code.2881 = code;
            code.3034 = code.2881;
            code.3035 = code.3034 + 1;
            code = code.3035;
            D.29080 = imb.b[1];
            *code.3034 = D.29080;
            code.2881 = code;
            code.3036 = code.2881;
            code.3037 = code.3036 + 1;
            code = code.3037;
            D.29083 = imb.b[2];
            *code.3036 = D.29083;
            code.2881 = code;
            code.3038 = code.2881;
            code.3039 = code.3038 + 1;
            code = code.3039;
            D.29086 = imb.b[3];
            *code.3038 = D.29086;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29087>;
      <D.29072>:
      D.28826 = cont_reg & 7;
      if (D.28826 == 4) goto <D.29088>; else goto <D.29089>;
      <D.29088>:
      if (0 != 0) goto <D.29090>; else goto <D.29091>;
      <D.29090>:
      code.2881 = code;
      code.3040 = code.2881;
      code.3041 = code.3040 + 1;
      code = code.3041;
      *code.3040 = 60;
      code.2881 = code;
      code.3042 = code.2881;
      code.3043 = code.3042 + 1;
      code = code.3043;
      *code.3042 = 36;
      goto <D.29096>;
      <D.29091>:
      if (1 != 0) goto <D.29097>; else goto <D.29098>;
      <D.29097>:
      code.2881 = code;
      code.3044 = code.2881;
      code.3045 = code.3044 + 1;
      code = code.3045;
      *code.3044 = 124;
      code.2881 = code;
      code.3046 = code.2881;
      code.3047 = code.3046 + 1;
      code = code.3047;
      *code.3046 = 36;
      code.2881 = code;
      *code.2881 = 40;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29103>;
      <D.29098>:
      code.2881 = code;
      code.3048 = code.2881;
      code.3049 = code.3048 + 1;
      code = code.3049;
      *code.3048 = 188;
      code.2881 = code;
      code.3050 = code.2881;
      code.3051 = code.3050 + 1;
      code = code.3051;
      *code.3050 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3052 = code.2881;
            code.3053 = code.3052 + 1;
            code = code.3053;
            D.29110 = imb.b[0];
            *code.3052 = D.29110;
            code.2881 = code;
            code.3054 = code.2881;
            code.3055 = code.3054 + 1;
            code = code.3055;
            D.29113 = imb.b[1];
            *code.3054 = D.29113;
            code.2881 = code;
            code.3056 = code.2881;
            code.3057 = code.3056 + 1;
            code = code.3057;
            D.29116 = imb.b[2];
            *code.3056 = D.29116;
            code.2881 = code;
            code.3058 = code.2881;
            code.3059 = code.3058 + 1;
            code = code.3059;
            D.29119 = imb.b[3];
            *code.3058 = D.29119;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29103>:
      <D.29096>:
      goto <D.23555>;
      <D.29089>:
      if (0 != 0) goto <D.29120>; else goto <D.29121>;
      <D.29120>:
      code.2881 = code;
      code.3060 = code.2881;
      code.3061 = code.3060 + 1;
      code = code.3061;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29124 = D.28915 | 56;
      D.29125 = (unsigned char) D.29124;
      *code.3060 = D.29125;
      goto <D.23555>;
      <D.29121>:
      if (1 != 0) goto <D.29126>; else goto <D.29127>;
      <D.29126>:
      code.2881 = code;
      code.3062 = code.2881;
      code.3063 = code.3062 + 1;
      code = code.3063;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29130 = D.28915 | 120;
      D.29131 = (unsigned char) D.29130;
      *code.3062 = D.29131;
      code.2881 = code;
      *code.2881 = 40;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29132>;
      <D.29127>:
      code.2881 = code;
      code.3064 = code.2881;
      code.3065 = code.3064 + 1;
      code = code.3065;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29135 = D.28915 | -72;
      D.29136 = (unsigned char) D.29135;
      *code.3064 = D.29136;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3066 = code.2881;
            code.3067 = code.3066 + 1;
            code = code.3067;
            D.29139 = imb.b[0];
            *code.3066 = D.29139;
            code.2881 = code;
            code.3068 = code.2881;
            code.3069 = code.3068 + 1;
            code = code.3069;
            D.29142 = imb.b[1];
            *code.3068 = D.29142;
            code.2881 = code;
            code.3070 = code.2881;
            code.3071 = code.3070 + 1;
            code = code.3071;
            D.29145 = imb.b[2];
            *code.3070 = D.29145;
            code.2881 = code;
            code.3072 = code.2881;
            code.3073 = code.3072 + 1;
            code = code.3073;
            D.29148 = imb.b[3];
            *code.3072 = D.29148;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29132>:
      <D.23555>:
      <D.29087>:
      code.2881 = code;
      code.3074 = code.2881;
      code.3075 = code.3074 + 1;
      code = code.3075;
      *code.3074 = 243;
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.29151>; else goto <D.29152>;
        <D.29151>:
        code.2881 = code;
        code.3076 = code.2881;
        code.3077 = code.3076 + 1;
        code = code.3077;
        D.29155 = _amd64_rex_bits | 64;
        *code.3076 = D.29155;
        <D.29152>:
      }
      code.2881 = code;
      code.3078 = code.2881;
      code.3079 = code.3078 + 1;
      code = code.3079;
      *code.3078 = 165;
      if (0 != 0) goto <D.29158>; else goto <D.29159>;
      <D.29158>:
      code.2881 = code;
      code.3080 = code.2881;
      code.3081 = code.3080 + 1;
      code = code.3081;
      *code.3080 = 102;
      <D.29159>:
      {
        unsigned char _amd64_rex_bits;

        if (cont_reg > 7) goto <D.29163>; else goto <D.29164>;
        <D.29163>:
        iftmp.3082 = 9;
        goto <D.29165>;
        <D.29164>:
        iftmp.3082 = 8;
        <D.29165>:
        _amd64_rex_bits = iftmp.3082;
        if (_amd64_rex_bits != 0) goto <D.29166>; else goto <D.29167>;
        <D.29166>:
        code.2881 = code;
        code.3083 = code.2881;
        code.3084 = code.3083 + 1;
        code = code.3084;
        D.29170 = _amd64_rex_bits | 64;
        *code.3083 = D.29170;
        <D.29167>:
      }
      switch (8) <default: <D.23564>, case 1: <D.23559>, case 2: <D.23561>, case 4: <D.23562>, case 8: <D.23563>>
      <D.23559>:
      code.2881 = code;
      code.3085 = code.2881;
      code.3086 = code.3085 + 1;
      code = code.3086;
      *code.3085 = 138;
      goto <D.23560>;
      <D.23561>:
      <D.23562>:
      <D.23563>:
      code.2881 = code;
      code.3087 = code.2881;
      code.3088 = code.3087 + 1;
      code = code.3088;
      *code.3087 = 139;
      goto <D.23560>;
      <D.23564>:
      __assert_fail ("0", "exceptions-amd64.c", 1432, &__PRETTY_FUNCTION__);
      <D.23560>:
      if (cont_reg == 16) goto <D.29175>; else goto <D.29176>;
      <D.29175>:
      code.2881 = code;
      code.3089 = code.2881;
      code.3090 = code.3089 + 1;
      code = code.3090;
      *code.3089 = 13;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2881 = code;
            code.3091 = code.2881;
            code.3092 = code.3091 + 1;
            code = code.3092;
            D.29181 = imb.b[0];
            *code.3091 = D.29181;
            code.2881 = code;
            code.3093 = code.2881;
            code.3094 = code.3093 + 1;
            code = code.3094;
            D.29184 = imb.b[1];
            *code.3093 = D.29184;
            code.2881 = code;
            code.3095 = code.2881;
            code.3096 = code.3095 + 1;
            code = code.3096;
            D.29187 = imb.b[2];
            *code.3095 = D.29187;
            code.2881 = code;
            code.3097 = code.2881;
            code.3098 = code.3097 + 1;
            code = code.3098;
            D.29190 = imb.b[3];
            *code.3097 = D.29190;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29191>;
      <D.29176>:
      D.28826 = cont_reg & 7;
      if (D.28826 == 4) goto <D.29192>; else goto <D.29193>;
      <D.29192>:
      if (1 != 0) goto <D.29194>; else goto <D.29195>;
      <D.29194>:
      code.2881 = code;
      code.3099 = code.2881;
      code.3100 = code.3099 + 1;
      code = code.3100;
      *code.3099 = 12;
      code.2881 = code;
      code.3101 = code.2881;
      code.3102 = code.3101 + 1;
      code = code.3102;
      *code.3101 = 36;
      goto <D.29200>;
      <D.29195>:
      if (1 != 0) goto <D.29201>; else goto <D.29202>;
      <D.29201>:
      code.2881 = code;
      code.3103 = code.2881;
      code.3104 = code.3103 + 1;
      code = code.3104;
      *code.3103 = 76;
      code.2881 = code;
      code.3105 = code.2881;
      code.3106 = code.3105 + 1;
      code = code.3106;
      *code.3105 = 36;
      code.2881 = code;
      *code.2881 = 0;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29207>;
      <D.29202>:
      code.2881 = code;
      code.3107 = code.2881;
      code.3108 = code.3107 + 1;
      code = code.3108;
      *code.3107 = 140;
      code.2881 = code;
      code.3109 = code.2881;
      code.3110 = code.3109 + 1;
      code = code.3110;
      *code.3109 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2881 = code;
            code.3111 = code.2881;
            code.3112 = code.3111 + 1;
            code = code.3112;
            D.29214 = imb.b[0];
            *code.3111 = D.29214;
            code.2881 = code;
            code.3113 = code.2881;
            code.3114 = code.3113 + 1;
            code = code.3114;
            D.29217 = imb.b[1];
            *code.3113 = D.29217;
            code.2881 = code;
            code.3115 = code.2881;
            code.3116 = code.3115 + 1;
            code = code.3116;
            D.29220 = imb.b[2];
            *code.3115 = D.29220;
            code.2881 = code;
            code.3117 = code.2881;
            code.3118 = code.3117 + 1;
            code = code.3118;
            D.29223 = imb.b[3];
            *code.3117 = D.29223;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29207>:
      <D.29200>:
      goto <D.23567>;
      <D.29193>:
      D.28826 = cont_reg & 7;
      if (D.28826 != 5) goto <D.29224>; else goto <D.29225>;
      <D.29224>:
      code.2881 = code;
      code.3119 = code.2881;
      code.3120 = code.3119 + 1;
      code = code.3120;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28916 = D.28915 | 8;
      D.28917 = (unsigned char) D.28916;
      *code.3119 = D.28917;
      goto <D.23567>;
      <D.29225>:
      if (1 != 0) goto <D.29228>; else goto <D.29229>;
      <D.29228>:
      code.2881 = code;
      code.3121 = code.2881;
      code.3122 = code.3121 + 1;
      code = code.3122;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28922 = D.28915 | 72;
      D.28923 = (unsigned char) D.28922;
      *code.3121 = D.28923;
      code.2881 = code;
      *code.2881 = 0;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29232>;
      <D.29229>:
      code.2881 = code;
      code.3123 = code.2881;
      code.3124 = code.3123 + 1;
      code = code.3124;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.28927 = D.28915 | -120;
      D.28928 = (unsigned char) D.28927;
      *code.3123 = D.28928;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 0;
            code.2881 = code;
            code.3125 = code.2881;
            code.3126 = code.3125 + 1;
            code = code.3126;
            D.29237 = imb.b[0];
            *code.3125 = D.29237;
            code.2881 = code;
            code.3127 = code.2881;
            code.3128 = code.3127 + 1;
            code = code.3128;
            D.29240 = imb.b[1];
            *code.3127 = D.29240;
            code.2881 = code;
            code.3129 = code.2881;
            code.3130 = code.3129 + 1;
            code = code.3130;
            D.29243 = imb.b[2];
            *code.3129 = D.29243;
            code.2881 = code;
            code.3131 = code.2881;
            code.3132 = code.3131 + 1;
            code = code.3132;
            D.29246 = imb.b[3];
            *code.3131 = D.29246;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29232>:
      <D.23567>:
      <D.29191>:
      if (0 != 0) goto <D.29247>; else goto <D.29248>;
      <D.29247>:
      code.2881 = code;
      code.3133 = code.2881;
      code.3134 = code.3133 + 1;
      code = code.3134;
      *code.3133 = 102;
      <D.29248>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.29251>; else goto <D.29252>;
        <D.29251>:
        code.2881 = code;
        code.3135 = code.2881;
        code.3136 = code.3135 + 1;
        code = code.3136;
        D.29255 = _amd64_rex_bits | 64;
        *code.3135 = D.29255;
        <D.29252>:
      }
      switch (8) <default: <D.23575>, case 1: <D.23570>, case 2: <D.23572>, case 4: <D.23573>, case 8: <D.23574>>
      <D.23570>:
      code.2881 = code;
      code.3137 = code.2881;
      code.3138 = code.3137 + 1;
      code = code.3138;
      *code.3137 = 138;
      goto <D.23571>;
      <D.23572>:
      <D.23573>:
      <D.23574>:
      code.2881 = code;
      code.3139 = code.2881;
      code.3140 = code.3139 + 1;
      code = code.3140;
      *code.3139 = 139;
      goto <D.23571>;
      <D.23575>:
      __assert_fail ("0", "exceptions-amd64.c", 1433, &__PRETTY_FUNCTION__);
      <D.23571>:
      if (0 != 0) goto <D.29260>; else goto <D.29261>;
      <D.29260>:
      code.2881 = code;
      code.3141 = code.2881;
      code.3142 = code.3141 + 1;
      code = code.3142;
      *code.3141 = 29;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.2881 = code;
            code.3143 = code.2881;
            code.3144 = code.3143 + 1;
            code = code.3144;
            D.29266 = imb.b[0];
            *code.3143 = D.29266;
            code.2881 = code;
            code.3145 = code.2881;
            code.3146 = code.3145 + 1;
            code = code.3146;
            D.29269 = imb.b[1];
            *code.3145 = D.29269;
            code.2881 = code;
            code.3147 = code.2881;
            code.3148 = code.3147 + 1;
            code = code.3148;
            D.29272 = imb.b[2];
            *code.3147 = D.29272;
            code.2881 = code;
            code.3149 = code.2881;
            code.3150 = code.3149 + 1;
            code = code.3150;
            D.29275 = imb.b[3];
            *code.3149 = D.29275;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29276>;
      <D.29261>:
      if (0 != 0) goto <D.29277>; else goto <D.29278>;
      <D.29277>:
      if (0 != 0) goto <D.29279>; else goto <D.29280>;
      <D.29279>:
      code.2881 = code;
      code.3151 = code.2881;
      code.3152 = code.3151 + 1;
      code = code.3152;
      *code.3151 = 28;
      code.2881 = code;
      code.3153 = code.2881;
      code.3154 = code.3153 + 1;
      code = code.3154;
      *code.3153 = 36;
      goto <D.29285>;
      <D.29280>:
      if (1 != 0) goto <D.29286>; else goto <D.29287>;
      <D.29286>:
      code.2881 = code;
      code.3155 = code.2881;
      code.3156 = code.3155 + 1;
      code = code.3156;
      *code.3155 = 92;
      code.2881 = code;
      code.3157 = code.2881;
      code.3158 = code.3157 + 1;
      code = code.3158;
      *code.3157 = 36;
      code.2881 = code;
      *code.2881 = 16;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29292>;
      <D.29287>:
      code.2881 = code;
      code.3159 = code.2881;
      code.3160 = code.3159 + 1;
      code = code.3160;
      *code.3159 = 156;
      code.2881 = code;
      code.3161 = code.2881;
      code.3162 = code.3161 + 1;
      code = code.3162;
      *code.3161 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.2881 = code;
            code.3163 = code.2881;
            code.3164 = code.3163 + 1;
            code = code.3164;
            D.29299 = imb.b[0];
            *code.3163 = D.29299;
            code.2881 = code;
            code.3165 = code.2881;
            code.3166 = code.3165 + 1;
            code = code.3166;
            D.29302 = imb.b[1];
            *code.3165 = D.29302;
            code.2881 = code;
            code.3167 = code.2881;
            code.3168 = code.3167 + 1;
            code = code.3168;
            D.29305 = imb.b[2];
            *code.3167 = D.29305;
            code.2881 = code;
            code.3169 = code.2881;
            code.3170 = code.3169 + 1;
            code = code.3170;
            D.29308 = imb.b[3];
            *code.3169 = D.29308;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29292>:
      <D.29285>:
      goto <D.23578>;
      <D.29278>:
      if (0 != 0) goto <D.29309>; else goto <D.29310>;
      <D.29309>:
      code.2881 = code;
      code.3171 = code.2881;
      code.3172 = code.3171 + 1;
      code = code.3172;
      *code.3171 = 25;
      goto <D.23578>;
      <D.29310>:
      if (1 != 0) goto <D.29313>; else goto <D.29314>;
      <D.29313>:
      code.2881 = code;
      code.3173 = code.2881;
      code.3174 = code.3173 + 1;
      code = code.3174;
      *code.3173 = 89;
      code.2881 = code;
      *code.2881 = 16;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29317>;
      <D.29314>:
      code.2881 = code;
      code.3175 = code.2881;
      code.3176 = code.3175 + 1;
      code = code.3176;
      *code.3175 = 153;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 16;
            code.2881 = code;
            code.3177 = code.2881;
            code.3178 = code.3177 + 1;
            code = code.3178;
            D.29322 = imb.b[0];
            *code.3177 = D.29322;
            code.2881 = code;
            code.3179 = code.2881;
            code.3180 = code.3179 + 1;
            code = code.3180;
            D.29325 = imb.b[1];
            *code.3179 = D.29325;
            code.2881 = code;
            code.3181 = code.2881;
            code.3182 = code.3181 + 1;
            code = code.3182;
            D.29328 = imb.b[2];
            *code.3181 = D.29328;
            code.2881 = code;
            code.3183 = code.2881;
            code.3184 = code.3183 + 1;
            code = code.3184;
            D.29331 = imb.b[3];
            *code.3183 = D.29331;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29317>:
      <D.23578>:
      <D.29276>:
      if (0 != 0) goto <D.29332>; else goto <D.29333>;
      <D.29332>:
      code.2881 = code;
      code.3185 = code.2881;
      code.3186 = code.3185 + 1;
      code = code.3186;
      *code.3185 = 102;
      <D.29333>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.29336>; else goto <D.29337>;
        <D.29336>:
        code.2881 = code;
        code.3187 = code.2881;
        code.3188 = code.3187 + 1;
        code = code.3188;
        D.29340 = _amd64_rex_bits | 64;
        *code.3187 = D.29340;
        <D.29337>:
      }
      switch (8) <default: <D.23586>, case 1: <D.23581>, case 2: <D.23583>, case 4: <D.23584>, case 8: <D.23585>>
      <D.23581>:
      code.2881 = code;
      code.3189 = code.2881;
      code.3190 = code.3189 + 1;
      code = code.3190;
      *code.3189 = 138;
      goto <D.23582>;
      <D.23583>:
      <D.23584>:
      <D.23585>:
      code.2881 = code;
      code.3191 = code.2881;
      code.3192 = code.3191 + 1;
      code = code.3192;
      *code.3191 = 139;
      goto <D.23582>;
      <D.23586>:
      __assert_fail ("0", "exceptions-amd64.c", 1434, &__PRETTY_FUNCTION__);
      <D.23582>:
      if (0 != 0) goto <D.29345>; else goto <D.29346>;
      <D.29345>:
      code.2881 = code;
      code.3193 = code.2881;
      code.3194 = code.3193 + 1;
      code = code.3194;
      *code.3193 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.2881 = code;
            code.3195 = code.2881;
            code.3196 = code.3195 + 1;
            code = code.3196;
            D.29351 = imb.b[0];
            *code.3195 = D.29351;
            code.2881 = code;
            code.3197 = code.2881;
            code.3198 = code.3197 + 1;
            code = code.3198;
            D.29354 = imb.b[1];
            *code.3197 = D.29354;
            code.2881 = code;
            code.3199 = code.2881;
            code.3200 = code.3199 + 1;
            code = code.3200;
            D.29357 = imb.b[2];
            *code.3199 = D.29357;
            code.2881 = code;
            code.3201 = code.2881;
            code.3202 = code.3201 + 1;
            code = code.3202;
            D.29360 = imb.b[3];
            *code.3201 = D.29360;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29361>;
      <D.29346>:
      if (0 != 0) goto <D.29362>; else goto <D.29363>;
      <D.29362>:
      if (0 != 0) goto <D.29364>; else goto <D.29365>;
      <D.29364>:
      code.2881 = code;
      code.3203 = code.2881;
      code.3204 = code.3203 + 1;
      code = code.3204;
      *code.3203 = 44;
      code.2881 = code;
      code.3205 = code.2881;
      code.3206 = code.3205 + 1;
      code = code.3206;
      *code.3205 = 36;
      goto <D.29370>;
      <D.29365>:
      if (1 != 0) goto <D.29371>; else goto <D.29372>;
      <D.29371>:
      code.2881 = code;
      code.3207 = code.2881;
      code.3208 = code.3207 + 1;
      code = code.3208;
      *code.3207 = 108;
      code.2881 = code;
      code.3209 = code.2881;
      code.3210 = code.3209 + 1;
      code = code.3210;
      *code.3209 = 36;
      code.2881 = code;
      *code.2881 = 24;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29377>;
      <D.29372>:
      code.2881 = code;
      code.3211 = code.2881;
      code.3212 = code.3211 + 1;
      code = code.3212;
      *code.3211 = 172;
      code.2881 = code;
      code.3213 = code.2881;
      code.3214 = code.3213 + 1;
      code = code.3214;
      *code.3213 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.2881 = code;
            code.3215 = code.2881;
            code.3216 = code.3215 + 1;
            code = code.3216;
            D.29384 = imb.b[0];
            *code.3215 = D.29384;
            code.2881 = code;
            code.3217 = code.2881;
            code.3218 = code.3217 + 1;
            code = code.3218;
            D.29387 = imb.b[1];
            *code.3217 = D.29387;
            code.2881 = code;
            code.3219 = code.2881;
            code.3220 = code.3219 + 1;
            code = code.3220;
            D.29390 = imb.b[2];
            *code.3219 = D.29390;
            code.2881 = code;
            code.3221 = code.2881;
            code.3222 = code.3221 + 1;
            code = code.3222;
            D.29393 = imb.b[3];
            *code.3221 = D.29393;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29377>:
      <D.29370>:
      goto <D.23589>;
      <D.29363>:
      if (0 != 0) goto <D.29394>; else goto <D.29395>;
      <D.29394>:
      code.2881 = code;
      code.3223 = code.2881;
      code.3224 = code.3223 + 1;
      code = code.3224;
      *code.3223 = 41;
      goto <D.23589>;
      <D.29395>:
      if (1 != 0) goto <D.29398>; else goto <D.29399>;
      <D.29398>:
      code.2881 = code;
      code.3225 = code.2881;
      code.3226 = code.3225 + 1;
      code = code.3226;
      *code.3225 = 105;
      code.2881 = code;
      *code.2881 = 24;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29402>;
      <D.29399>:
      code.2881 = code;
      code.3227 = code.2881;
      code.3228 = code.3227 + 1;
      code = code.3228;
      *code.3227 = 169;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 24;
            code.2881 = code;
            code.3229 = code.2881;
            code.3230 = code.3229 + 1;
            code = code.3230;
            D.29407 = imb.b[0];
            *code.3229 = D.29407;
            code.2881 = code;
            code.3231 = code.2881;
            code.3232 = code.3231 + 1;
            code = code.3232;
            D.29410 = imb.b[1];
            *code.3231 = D.29410;
            code.2881 = code;
            code.3233 = code.2881;
            code.3234 = code.3233 + 1;
            code = code.3234;
            D.29413 = imb.b[2];
            *code.3233 = D.29413;
            code.2881 = code;
            code.3235 = code.2881;
            code.3236 = code.3235 + 1;
            code = code.3236;
            D.29416 = imb.b[3];
            *code.3235 = D.29416;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29402>:
      <D.23589>:
      <D.29361>:
      if (0 != 0) goto <D.29417>; else goto <D.29418>;
      <D.29417>:
      code.2881 = code;
      code.3237 = code.2881;
      code.3238 = code.3237 + 1;
      code = code.3238;
      *code.3237 = 102;
      <D.29418>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.29421>; else goto <D.29422>;
        <D.29421>:
        code.2881 = code;
        code.3239 = code.2881;
        code.3240 = code.3239 + 1;
        code = code.3240;
        D.29425 = _amd64_rex_bits | 64;
        *code.3239 = D.29425;
        <D.29422>:
      }
      switch (8) <default: <D.23597>, case 1: <D.23592>, case 2: <D.23594>, case 4: <D.23595>, case 8: <D.23596>>
      <D.23592>:
      code.2881 = code;
      code.3241 = code.2881;
      code.3242 = code.3241 + 1;
      code = code.3242;
      *code.3241 = 138;
      goto <D.23593>;
      <D.23594>:
      <D.23595>:
      <D.23596>:
      code.2881 = code;
      code.3243 = code.2881;
      code.3244 = code.3243 + 1;
      code = code.3244;
      *code.3243 = 139;
      goto <D.23593>;
      <D.23597>:
      __assert_fail ("0", "exceptions-amd64.c", 1435, &__PRETTY_FUNCTION__);
      <D.23593>:
      if (0 != 0) goto <D.29430>; else goto <D.29431>;
      <D.29430>:
      code.2881 = code;
      code.3245 = code.2881;
      code.3246 = code.3245 + 1;
      code = code.3246;
      *code.3245 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3247 = code.2881;
            code.3248 = code.3247 + 1;
            code = code.3248;
            D.29436 = imb.b[0];
            *code.3247 = D.29436;
            code.2881 = code;
            code.3249 = code.2881;
            code.3250 = code.3249 + 1;
            code = code.3250;
            D.29439 = imb.b[1];
            *code.3249 = D.29439;
            code.2881 = code;
            code.3251 = code.2881;
            code.3252 = code.3251 + 1;
            code = code.3252;
            D.29442 = imb.b[2];
            *code.3251 = D.29442;
            code.2881 = code;
            code.3253 = code.2881;
            code.3254 = code.3253 + 1;
            code = code.3254;
            D.29445 = imb.b[3];
            *code.3253 = D.29445;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29446>;
      <D.29431>:
      if (0 != 0) goto <D.29447>; else goto <D.29448>;
      <D.29447>:
      if (0 != 0) goto <D.29449>; else goto <D.29450>;
      <D.29449>:
      code.2881 = code;
      code.3255 = code.2881;
      code.3256 = code.3255 + 1;
      code = code.3256;
      *code.3255 = 36;
      code.2881 = code;
      code.3257 = code.2881;
      code.3258 = code.3257 + 1;
      code = code.3258;
      *code.3257 = 36;
      goto <D.29455>;
      <D.29450>:
      if (1 != 0) goto <D.29456>; else goto <D.29457>;
      <D.29456>:
      code.2881 = code;
      code.3259 = code.2881;
      code.3260 = code.3259 + 1;
      code = code.3260;
      *code.3259 = 100;
      code.2881 = code;
      code.3261 = code.2881;
      code.3262 = code.3261 + 1;
      code = code.3262;
      *code.3261 = 36;
      code.2881 = code;
      *code.2881 = 40;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29462>;
      <D.29457>:
      code.2881 = code;
      code.3263 = code.2881;
      code.3264 = code.3263 + 1;
      code = code.3264;
      *code.3263 = 164;
      code.2881 = code;
      code.3265 = code.2881;
      code.3266 = code.3265 + 1;
      code = code.3266;
      *code.3265 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3267 = code.2881;
            code.3268 = code.3267 + 1;
            code = code.3268;
            D.29469 = imb.b[0];
            *code.3267 = D.29469;
            code.2881 = code;
            code.3269 = code.2881;
            code.3270 = code.3269 + 1;
            code = code.3270;
            D.29472 = imb.b[1];
            *code.3269 = D.29472;
            code.2881 = code;
            code.3271 = code.2881;
            code.3272 = code.3271 + 1;
            code = code.3272;
            D.29475 = imb.b[2];
            *code.3271 = D.29475;
            code.2881 = code;
            code.3273 = code.2881;
            code.3274 = code.3273 + 1;
            code = code.3274;
            D.29478 = imb.b[3];
            *code.3273 = D.29478;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29462>:
      <D.29455>:
      goto <D.23600>;
      <D.29448>:
      if (0 != 0) goto <D.29479>; else goto <D.29480>;
      <D.29479>:
      code.2881 = code;
      code.3275 = code.2881;
      code.3276 = code.3275 + 1;
      code = code.3276;
      *code.3275 = 33;
      goto <D.23600>;
      <D.29480>:
      if (1 != 0) goto <D.29483>; else goto <D.29484>;
      <D.29483>:
      code.2881 = code;
      code.3277 = code.2881;
      code.3278 = code.3277 + 1;
      code = code.3278;
      *code.3277 = 97;
      code.2881 = code;
      *code.2881 = 40;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29487>;
      <D.29484>:
      code.2881 = code;
      code.3279 = code.2881;
      code.3280 = code.3279 + 1;
      code = code.3280;
      *code.3279 = 161;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 40;
            code.2881 = code;
            code.3281 = code.2881;
            code.3282 = code.3281 + 1;
            code = code.3282;
            D.29492 = imb.b[0];
            *code.3281 = D.29492;
            code.2881 = code;
            code.3283 = code.2881;
            code.3284 = code.3283 + 1;
            code = code.3284;
            D.29495 = imb.b[1];
            *code.3283 = D.29495;
            code.2881 = code;
            code.3285 = code.2881;
            code.3286 = code.3285 + 1;
            code = code.3286;
            D.29498 = imb.b[2];
            *code.3285 = D.29498;
            code.2881 = code;
            code.3287 = code.2881;
            code.3288 = code.3287 + 1;
            code = code.3288;
            D.29501 = imb.b[3];
            *code.3287 = D.29501;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29487>:
      <D.23600>:
      <D.29446>:
      if (0 != 0) goto <D.29502>; else goto <D.29503>;
      <D.29502>:
      code.2881 = code;
      code.3289 = code.2881;
      code.3290 = code.3289 + 1;
      code = code.3290;
      *code.3289 = 102;
      <D.29503>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.29506>; else goto <D.29507>;
        <D.29506>:
        code.2881 = code;
        code.3291 = code.2881;
        code.3292 = code.3291 + 1;
        code = code.3292;
        D.29510 = _amd64_rex_bits | 64;
        *code.3291 = D.29510;
        <D.29507>:
      }
      switch (8) <default: <D.23608>, case 1: <D.23603>, case 2: <D.23605>, case 4: <D.23606>, case 8: <D.23607>>
      <D.23603>:
      code.2881 = code;
      code.3293 = code.2881;
      code.3294 = code.3293 + 1;
      code = code.3294;
      *code.3293 = 138;
      goto <D.23604>;
      <D.23605>:
      <D.23606>:
      <D.23607>:
      code.2881 = code;
      code.3295 = code.2881;
      code.3296 = code.3295 + 1;
      code = code.3296;
      *code.3295 = 139;
      goto <D.23604>;
      <D.23608>:
      __assert_fail ("0", "exceptions-amd64.c", 1436, &__PRETTY_FUNCTION__);
      <D.23604>:
      if (0 != 0) goto <D.29515>; else goto <D.29516>;
      <D.29515>:
      code.2881 = code;
      code.3297 = code.2881;
      code.3298 = code.3297 + 1;
      code = code.3298;
      *code.3297 = 45;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.2881 = code;
            code.3299 = code.2881;
            code.3300 = code.3299 + 1;
            code = code.3300;
            D.29521 = imb.b[0];
            *code.3299 = D.29521;
            code.2881 = code;
            code.3301 = code.2881;
            code.3302 = code.3301 + 1;
            code = code.3302;
            D.29524 = imb.b[1];
            *code.3301 = D.29524;
            code.2881 = code;
            code.3303 = code.2881;
            code.3304 = code.3303 + 1;
            code = code.3304;
            D.29527 = imb.b[2];
            *code.3303 = D.29527;
            code.2881 = code;
            code.3305 = code.2881;
            code.3306 = code.3305 + 1;
            code = code.3306;
            D.29530 = imb.b[3];
            *code.3305 = D.29530;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29531>;
      <D.29516>:
      if (0 != 0) goto <D.29532>; else goto <D.29533>;
      <D.29532>:
      if (0 != 0) goto <D.29534>; else goto <D.29535>;
      <D.29534>:
      code.2881 = code;
      code.3307 = code.2881;
      code.3308 = code.3307 + 1;
      code = code.3308;
      *code.3307 = 44;
      code.2881 = code;
      code.3309 = code.2881;
      code.3310 = code.3309 + 1;
      code = code.3310;
      *code.3309 = 36;
      goto <D.29540>;
      <D.29535>:
      if (1 != 0) goto <D.29541>; else goto <D.29542>;
      <D.29541>:
      code.2881 = code;
      code.3311 = code.2881;
      code.3312 = code.3311 + 1;
      code = code.3312;
      *code.3311 = 108;
      code.2881 = code;
      code.3313 = code.2881;
      code.3314 = code.3313 + 1;
      code = code.3314;
      *code.3313 = 36;
      code.2881 = code;
      *code.2881 = 48;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29547>;
      <D.29542>:
      code.2881 = code;
      code.3315 = code.2881;
      code.3316 = code.3315 + 1;
      code = code.3316;
      *code.3315 = 172;
      code.2881 = code;
      code.3317 = code.2881;
      code.3318 = code.3317 + 1;
      code = code.3318;
      *code.3317 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.2881 = code;
            code.3319 = code.2881;
            code.3320 = code.3319 + 1;
            code = code.3320;
            D.29554 = imb.b[0];
            *code.3319 = D.29554;
            code.2881 = code;
            code.3321 = code.2881;
            code.3322 = code.3321 + 1;
            code = code.3322;
            D.29557 = imb.b[1];
            *code.3321 = D.29557;
            code.2881 = code;
            code.3323 = code.2881;
            code.3324 = code.3323 + 1;
            code = code.3324;
            D.29560 = imb.b[2];
            *code.3323 = D.29560;
            code.2881 = code;
            code.3325 = code.2881;
            code.3326 = code.3325 + 1;
            code = code.3326;
            D.29563 = imb.b[3];
            *code.3325 = D.29563;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29547>:
      <D.29540>:
      goto <D.23611>;
      <D.29533>:
      if (0 != 0) goto <D.29564>; else goto <D.29565>;
      <D.29564>:
      code.2881 = code;
      code.3327 = code.2881;
      code.3328 = code.3327 + 1;
      code = code.3328;
      *code.3327 = 41;
      goto <D.23611>;
      <D.29565>:
      if (1 != 0) goto <D.29568>; else goto <D.29569>;
      <D.29568>:
      code.2881 = code;
      code.3329 = code.2881;
      code.3330 = code.3329 + 1;
      code = code.3330;
      *code.3329 = 105;
      code.2881 = code;
      *code.2881 = 48;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29572>;
      <D.29569>:
      code.2881 = code;
      code.3331 = code.2881;
      code.3332 = code.3331 + 1;
      code = code.3332;
      *code.3331 = 169;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 48;
            code.2881 = code;
            code.3333 = code.2881;
            code.3334 = code.3333 + 1;
            code = code.3334;
            D.29577 = imb.b[0];
            *code.3333 = D.29577;
            code.2881 = code;
            code.3335 = code.2881;
            code.3336 = code.3335 + 1;
            code = code.3336;
            D.29580 = imb.b[1];
            *code.3335 = D.29580;
            code.2881 = code;
            code.3337 = code.2881;
            code.3338 = code.3337 + 1;
            code = code.3338;
            D.29583 = imb.b[2];
            *code.3337 = D.29583;
            code.2881 = code;
            code.3339 = code.2881;
            code.3340 = code.3339 + 1;
            code = code.3340;
            D.29586 = imb.b[3];
            *code.3339 = D.29586;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29572>:
      <D.23611>:
      <D.29531>:
      if (0 != 0) goto <D.29587>; else goto <D.29588>;
      <D.29587>:
      code.2881 = code;
      code.3341 = code.2881;
      code.3342 = code.3341 + 1;
      code = code.3342;
      *code.3341 = 102;
      <D.29588>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.29591>; else goto <D.29592>;
        <D.29591>:
        code.2881 = code;
        code.3343 = code.2881;
        code.3344 = code.3343 + 1;
        code = code.3344;
        D.29595 = _amd64_rex_bits | 64;
        *code.3343 = D.29595;
        <D.29592>:
      }
      switch (8) <default: <D.23619>, case 1: <D.23614>, case 2: <D.23616>, case 4: <D.23617>, case 8: <D.23618>>
      <D.23614>:
      code.2881 = code;
      code.3345 = code.2881;
      code.3346 = code.3345 + 1;
      code = code.3346;
      *code.3345 = 138;
      goto <D.23615>;
      <D.23616>:
      <D.23617>:
      <D.23618>:
      code.2881 = code;
      code.3347 = code.2881;
      code.3348 = code.3347 + 1;
      code = code.3348;
      *code.3347 = 139;
      goto <D.23615>;
      <D.23619>:
      __assert_fail ("0", "exceptions-amd64.c", 1437, &__PRETTY_FUNCTION__);
      <D.23615>:
      if (0 != 0) goto <D.29600>; else goto <D.29601>;
      <D.29600>:
      code.2881 = code;
      code.3349 = code.2881;
      code.3350 = code.3349 + 1;
      code = code.3350;
      *code.3349 = 53;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.3351 = code.2881;
            code.3352 = code.3351 + 1;
            code = code.3352;
            D.29606 = imb.b[0];
            *code.3351 = D.29606;
            code.2881 = code;
            code.3353 = code.2881;
            code.3354 = code.3353 + 1;
            code = code.3354;
            D.29609 = imb.b[1];
            *code.3353 = D.29609;
            code.2881 = code;
            code.3355 = code.2881;
            code.3356 = code.3355 + 1;
            code = code.3356;
            D.29612 = imb.b[2];
            *code.3355 = D.29612;
            code.2881 = code;
            code.3357 = code.2881;
            code.3358 = code.3357 + 1;
            code = code.3358;
            D.29615 = imb.b[3];
            *code.3357 = D.29615;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29616>;
      <D.29601>:
      if (0 != 0) goto <D.29617>; else goto <D.29618>;
      <D.29617>:
      if (0 != 0) goto <D.29619>; else goto <D.29620>;
      <D.29619>:
      code.2881 = code;
      code.3359 = code.2881;
      code.3360 = code.3359 + 1;
      code = code.3360;
      *code.3359 = 52;
      code.2881 = code;
      code.3361 = code.2881;
      code.3362 = code.3361 + 1;
      code = code.3362;
      *code.3361 = 36;
      goto <D.29625>;
      <D.29620>:
      if (1 != 0) goto <D.29626>; else goto <D.29627>;
      <D.29626>:
      code.2881 = code;
      code.3363 = code.2881;
      code.3364 = code.3363 + 1;
      code = code.3364;
      *code.3363 = 116;
      code.2881 = code;
      code.3365 = code.2881;
      code.3366 = code.3365 + 1;
      code = code.3366;
      *code.3365 = 36;
      code.2881 = code;
      *code.2881 = 56;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29632>;
      <D.29627>:
      code.2881 = code;
      code.3367 = code.2881;
      code.3368 = code.3367 + 1;
      code = code.3368;
      *code.3367 = 180;
      code.2881 = code;
      code.3369 = code.2881;
      code.3370 = code.3369 + 1;
      code = code.3370;
      *code.3369 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.3371 = code.2881;
            code.3372 = code.3371 + 1;
            code = code.3372;
            D.29639 = imb.b[0];
            *code.3371 = D.29639;
            code.2881 = code;
            code.3373 = code.2881;
            code.3374 = code.3373 + 1;
            code = code.3374;
            D.29642 = imb.b[1];
            *code.3373 = D.29642;
            code.2881 = code;
            code.3375 = code.2881;
            code.3376 = code.3375 + 1;
            code = code.3376;
            D.29645 = imb.b[2];
            *code.3375 = D.29645;
            code.2881 = code;
            code.3377 = code.2881;
            code.3378 = code.3377 + 1;
            code = code.3378;
            D.29648 = imb.b[3];
            *code.3377 = D.29648;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29632>:
      <D.29625>:
      goto <D.23622>;
      <D.29618>:
      if (0 != 0) goto <D.29649>; else goto <D.29650>;
      <D.29649>:
      code.2881 = code;
      code.3379 = code.2881;
      code.3380 = code.3379 + 1;
      code = code.3380;
      *code.3379 = 49;
      goto <D.23622>;
      <D.29650>:
      if (1 != 0) goto <D.29653>; else goto <D.29654>;
      <D.29653>:
      code.2881 = code;
      code.3381 = code.2881;
      code.3382 = code.3381 + 1;
      code = code.3382;
      *code.3381 = 113;
      code.2881 = code;
      *code.2881 = 56;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29657>;
      <D.29654>:
      code.2881 = code;
      code.3383 = code.2881;
      code.3384 = code.3383 + 1;
      code = code.3384;
      *code.3383 = 177;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 56;
            code.2881 = code;
            code.3385 = code.2881;
            code.3386 = code.3385 + 1;
            code = code.3386;
            D.29662 = imb.b[0];
            *code.3385 = D.29662;
            code.2881 = code;
            code.3387 = code.2881;
            code.3388 = code.3387 + 1;
            code = code.3388;
            D.29665 = imb.b[1];
            *code.3387 = D.29665;
            code.2881 = code;
            code.3389 = code.2881;
            code.3390 = code.3389 + 1;
            code = code.3390;
            D.29668 = imb.b[2];
            *code.3389 = D.29668;
            code.2881 = code;
            code.3391 = code.2881;
            code.3392 = code.3391 + 1;
            code = code.3392;
            D.29671 = imb.b[3];
            *code.3391 = D.29671;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29657>:
      <D.23622>:
      <D.29616>:
      if (0 != 0) goto <D.29672>; else goto <D.29673>;
      <D.29672>:
      code.2881 = code;
      code.3393 = code.2881;
      code.3394 = code.3393 + 1;
      code = code.3394;
      *code.3393 = 102;
      <D.29673>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 12;
        if (_amd64_rex_bits != 0) goto <D.29676>; else goto <D.29677>;
        <D.29676>:
        code.2881 = code;
        code.3395 = code.2881;
        code.3396 = code.3395 + 1;
        code = code.3396;
        D.29680 = _amd64_rex_bits | 64;
        *code.3395 = D.29680;
        <D.29677>:
      }
      switch (8) <default: <D.23630>, case 1: <D.23625>, case 2: <D.23627>, case 4: <D.23628>, case 8: <D.23629>>
      <D.23625>:
      code.2881 = code;
      code.3397 = code.2881;
      code.3398 = code.3397 + 1;
      code = code.3398;
      *code.3397 = 138;
      goto <D.23626>;
      <D.23627>:
      <D.23628>:
      <D.23629>:
      code.2881 = code;
      code.3399 = code.2881;
      code.3400 = code.3399 + 1;
      code = code.3400;
      *code.3399 = 139;
      goto <D.23626>;
      <D.23630>:
      __assert_fail ("0", "exceptions-amd64.c", 1439, &__PRETTY_FUNCTION__);
      <D.23626>:
      if (0 != 0) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      code.2881 = code;
      code.3401 = code.2881;
      code.3402 = code.3401 + 1;
      code = code.3402;
      *code.3401 = 61;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 64;
            code.2881 = code;
            code.3403 = code.2881;
            code.3404 = code.3403 + 1;
            code = code.3404;
            D.29691 = imb.b[0];
            *code.3403 = D.29691;
            code.2881 = code;
            code.3405 = code.2881;
            code.3406 = code.3405 + 1;
            code = code.3406;
            D.29694 = imb.b[1];
            *code.3405 = D.29694;
            code.2881 = code;
            code.3407 = code.2881;
            code.3408 = code.3407 + 1;
            code = code.3408;
            D.29697 = imb.b[2];
            *code.3407 = D.29697;
            code.2881 = code;
            code.3409 = code.2881;
            code.3410 = code.3409 + 1;
            code = code.3410;
            D.29700 = imb.b[3];
            *code.3409 = D.29700;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29701>;
      <D.29686>:
      if (0 != 0) goto <D.29702>; else goto <D.29703>;
      <D.29702>:
      if (0 != 0) goto <D.29704>; else goto <D.29705>;
      <D.29704>:
      code.2881 = code;
      code.3411 = code.2881;
      code.3412 = code.3411 + 1;
      code = code.3412;
      *code.3411 = 60;
      code.2881 = code;
      code.3413 = code.2881;
      code.3414 = code.3413 + 1;
      code = code.3414;
      *code.3413 = 36;
      goto <D.29710>;
      <D.29705>:
      if (1 != 0) goto <D.29711>; else goto <D.29712>;
      <D.29711>:
      code.2881 = code;
      code.3415 = code.2881;
      code.3416 = code.3415 + 1;
      code = code.3416;
      *code.3415 = 124;
      code.2881 = code;
      code.3417 = code.2881;
      code.3418 = code.3417 + 1;
      code = code.3418;
      *code.3417 = 36;
      code.2881 = code;
      *code.2881 = 64;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29717>;
      <D.29712>:
      code.2881 = code;
      code.3419 = code.2881;
      code.3420 = code.3419 + 1;
      code = code.3420;
      *code.3419 = 188;
      code.2881 = code;
      code.3421 = code.2881;
      code.3422 = code.3421 + 1;
      code = code.3422;
      *code.3421 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 64;
            code.2881 = code;
            code.3423 = code.2881;
            code.3424 = code.3423 + 1;
            code = code.3424;
            D.29724 = imb.b[0];
            *code.3423 = D.29724;
            code.2881 = code;
            code.3425 = code.2881;
            code.3426 = code.3425 + 1;
            code = code.3426;
            D.29727 = imb.b[1];
            *code.3425 = D.29727;
            code.2881 = code;
            code.3427 = code.2881;
            code.3428 = code.3427 + 1;
            code = code.3428;
            D.29730 = imb.b[2];
            *code.3427 = D.29730;
            code.2881 = code;
            code.3429 = code.2881;
            code.3430 = code.3429 + 1;
            code = code.3430;
            D.29733 = imb.b[3];
            *code.3429 = D.29733;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29717>:
      <D.29710>:
      goto <D.23633>;
      <D.29703>:
      if (0 != 0) goto <D.29734>; else goto <D.29735>;
      <D.29734>:
      code.2881 = code;
      code.3431 = code.2881;
      code.3432 = code.3431 + 1;
      code = code.3432;
      *code.3431 = 57;
      goto <D.23633>;
      <D.29735>:
      if (1 != 0) goto <D.29738>; else goto <D.29739>;
      <D.29738>:
      code.2881 = code;
      code.3433 = code.2881;
      code.3434 = code.3433 + 1;
      code = code.3434;
      *code.3433 = 121;
      code.2881 = code;
      *code.2881 = 64;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29742>;
      <D.29739>:
      code.2881 = code;
      code.3435 = code.2881;
      code.3436 = code.3435 + 1;
      code = code.3436;
      *code.3435 = 185;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 64;
            code.2881 = code;
            code.3437 = code.2881;
            code.3438 = code.3437 + 1;
            code = code.3438;
            D.29747 = imb.b[0];
            *code.3437 = D.29747;
            code.2881 = code;
            code.3439 = code.2881;
            code.3440 = code.3439 + 1;
            code = code.3440;
            D.29750 = imb.b[1];
            *code.3439 = D.29750;
            code.2881 = code;
            code.3441 = code.2881;
            code.3442 = code.3441 + 1;
            code = code.3442;
            D.29753 = imb.b[2];
            *code.3441 = D.29753;
            code.2881 = code;
            code.3443 = code.2881;
            code.3444 = code.3443 + 1;
            code = code.3444;
            D.29756 = imb.b[3];
            *code.3443 = D.29756;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29742>:
      <D.23633>:
      <D.29701>:
      if (0 != 0) goto <D.29757>; else goto <D.29758>;
      <D.29757>:
      code.2881 = code;
      code.3445 = code.2881;
      code.3446 = code.3445 + 1;
      code = code.3446;
      *code.3445 = 102;
      <D.29758>:
      {
        unsigned char _amd64_rex_bits;

        _amd64_rex_bits = 8;
        if (_amd64_rex_bits != 0) goto <D.29761>; else goto <D.29762>;
        <D.29761>:
        code.2881 = code;
        code.3447 = code.2881;
        code.3448 = code.3447 + 1;
        code = code.3448;
        D.29765 = _amd64_rex_bits | 64;
        *code.3447 = D.29765;
        <D.29762>:
      }
      switch (8) <default: <D.23641>, case 1: <D.23636>, case 2: <D.23638>, case 4: <D.23639>, case 8: <D.23640>>
      <D.23636>:
      code.2881 = code;
      code.3449 = code.2881;
      code.3450 = code.3449 + 1;
      code = code.3450;
      *code.3449 = 138;
      goto <D.23637>;
      <D.23638>:
      <D.23639>:
      <D.23640>:
      code.2881 = code;
      code.3451 = code.2881;
      code.3452 = code.3451 + 1;
      code = code.3452;
      *code.3451 = 139;
      goto <D.23637>;
      <D.23641>:
      __assert_fail ("0", "exceptions-amd64.c", 1445, &__PRETTY_FUNCTION__);
      <D.23637>:
      if (0 != 0) goto <D.29770>; else goto <D.29771>;
      <D.29770>:
      code.2881 = code;
      code.3453 = code.2881;
      code.3454 = code.3453 + 1;
      code = code.3454;
      *code.3453 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3455 = code.2881;
            code.3456 = code.3455 + 1;
            code = code.3456;
            D.29776 = imb.b[0];
            *code.3455 = D.29776;
            code.2881 = code;
            code.3457 = code.2881;
            code.3458 = code.3457 + 1;
            code = code.3458;
            D.29779 = imb.b[1];
            *code.3457 = D.29779;
            code.2881 = code;
            code.3459 = code.2881;
            code.3460 = code.3459 + 1;
            code = code.3460;
            D.29782 = imb.b[2];
            *code.3459 = D.29782;
            code.2881 = code;
            code.3461 = code.2881;
            code.3462 = code.3461 + 1;
            code = code.3462;
            D.29785 = imb.b[3];
            *code.3461 = D.29785;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29786>;
      <D.29771>:
      if (0 != 0) goto <D.29787>; else goto <D.29788>;
      <D.29787>:
      if (0 != 0) goto <D.29789>; else goto <D.29790>;
      <D.29789>:
      code.2881 = code;
      code.3463 = code.2881;
      code.3464 = code.3463 + 1;
      code = code.3464;
      *code.3463 = 36;
      code.2881 = code;
      code.3465 = code.2881;
      code.3466 = code.3465 + 1;
      code = code.3466;
      *code.3465 = 36;
      goto <D.29795>;
      <D.29790>:
      if (1 != 0) goto <D.29796>; else goto <D.29797>;
      <D.29796>:
      code.2881 = code;
      code.3467 = code.2881;
      code.3468 = code.3467 + 1;
      code = code.3468;
      *code.3467 = 100;
      code.2881 = code;
      code.3469 = code.2881;
      code.3470 = code.3469 + 1;
      code = code.3470;
      *code.3469 = 36;
      code.2881 = code;
      *code.2881 = 32;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29802>;
      <D.29797>:
      code.2881 = code;
      code.3471 = code.2881;
      code.3472 = code.3471 + 1;
      code = code.3472;
      *code.3471 = 164;
      code.2881 = code;
      code.3473 = code.2881;
      code.3474 = code.3473 + 1;
      code = code.3474;
      *code.3473 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3475 = code.2881;
            code.3476 = code.3475 + 1;
            code = code.3476;
            D.29809 = imb.b[0];
            *code.3475 = D.29809;
            code.2881 = code;
            code.3477 = code.2881;
            code.3478 = code.3477 + 1;
            code = code.3478;
            D.29812 = imb.b[1];
            *code.3477 = D.29812;
            code.2881 = code;
            code.3479 = code.2881;
            code.3480 = code.3479 + 1;
            code = code.3480;
            D.29815 = imb.b[2];
            *code.3479 = D.29815;
            code.2881 = code;
            code.3481 = code.2881;
            code.3482 = code.3481 + 1;
            code = code.3482;
            D.29818 = imb.b[3];
            *code.3481 = D.29818;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29802>:
      <D.29795>:
      goto <D.23644>;
      <D.29788>:
      if (0 != 0) goto <D.29819>; else goto <D.29820>;
      <D.29819>:
      code.2881 = code;
      code.3483 = code.2881;
      code.3484 = code.3483 + 1;
      code = code.3484;
      *code.3483 = 33;
      goto <D.23644>;
      <D.29820>:
      if (1 != 0) goto <D.29823>; else goto <D.29824>;
      <D.29823>:
      code.2881 = code;
      code.3485 = code.2881;
      code.3486 = code.3485 + 1;
      code = code.3486;
      *code.3485 = 97;
      code.2881 = code;
      *code.2881 = 32;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29827>;
      <D.29824>:
      code.2881 = code;
      code.3487 = code.2881;
      code.3488 = code.3487 + 1;
      code = code.3488;
      *code.3487 = 161;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3489 = code.2881;
            code.3490 = code.3489 + 1;
            code = code.3490;
            D.29832 = imb.b[0];
            *code.3489 = D.29832;
            code.2881 = code;
            code.3491 = code.2881;
            code.3492 = code.3491 + 1;
            code = code.3492;
            D.29835 = imb.b[1];
            *code.3491 = D.29835;
            code.2881 = code;
            code.3493 = code.2881;
            code.3494 = code.3493 + 1;
            code = code.3494;
            D.29838 = imb.b[2];
            *code.3493 = D.29838;
            code.2881 = code;
            code.3495 = code.2881;
            code.3496 = code.3495 + 1;
            code = code.3496;
            D.29841 = imb.b[3];
            *code.3495 = D.29841;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29827>:
      <D.23644>:
      <D.29786>:
      {
        unsigned char _amd64_rex_bits;

        D.28850 = cont_reg > 7;
        _amd64_rex_bits = (unsigned char) D.28850;
        if (_amd64_rex_bits != 0) goto <D.29842>; else goto <D.29843>;
        <D.29842>:
        code.2881 = code;
        code.3497 = code.2881;
        code.3498 = code.3497 + 1;
        code = code.3498;
        D.29846 = _amd64_rex_bits | 64;
        *code.3497 = D.29846;
        <D.29843>:
      }
      code.2881 = code;
      code.3499 = code.2881;
      code.3500 = code.3499 + 1;
      code = code.3500;
      *code.3499 = 255;
      if (cont_reg == 16) goto <D.29849>; else goto <D.29850>;
      <D.29849>:
      code.2881 = code;
      code.3501 = code.2881;
      code.3502 = code.3501 + 1;
      code = code.3502;
      *code.3501 = 37;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3503 = code.2881;
            code.3504 = code.3503 + 1;
            code = code.3504;
            D.29855 = imb.b[0];
            *code.3503 = D.29855;
            code.2881 = code;
            code.3505 = code.2881;
            code.3506 = code.3505 + 1;
            code = code.3506;
            D.29858 = imb.b[1];
            *code.3505 = D.29858;
            code.2881 = code;
            code.3507 = code.2881;
            code.3508 = code.3507 + 1;
            code = code.3508;
            D.29861 = imb.b[2];
            *code.3507 = D.29861;
            code.2881 = code;
            code.3509 = code.2881;
            code.3510 = code.3509 + 1;
            code = code.3510;
            D.29864 = imb.b[3];
            *code.3509 = D.29864;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      goto <D.29865>;
      <D.29850>:
      D.28826 = cont_reg & 7;
      if (D.28826 == 4) goto <D.29866>; else goto <D.29867>;
      <D.29866>:
      if (0 != 0) goto <D.29868>; else goto <D.29869>;
      <D.29868>:
      code.2881 = code;
      code.3511 = code.2881;
      code.3512 = code.3511 + 1;
      code = code.3512;
      *code.3511 = 36;
      code.2881 = code;
      code.3513 = code.2881;
      code.3514 = code.3513 + 1;
      code = code.3514;
      *code.3513 = 36;
      goto <D.29874>;
      <D.29869>:
      if (1 != 0) goto <D.29875>; else goto <D.29876>;
      <D.29875>:
      code.2881 = code;
      code.3515 = code.2881;
      code.3516 = code.3515 + 1;
      code = code.3516;
      *code.3515 = 100;
      code.2881 = code;
      code.3517 = code.2881;
      code.3518 = code.3517 + 1;
      code = code.3518;
      *code.3517 = 36;
      code.2881 = code;
      *code.2881 = 32;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29881>;
      <D.29876>:
      code.2881 = code;
      code.3519 = code.2881;
      code.3520 = code.3519 + 1;
      code = code.3520;
      *code.3519 = 164;
      code.2881 = code;
      code.3521 = code.2881;
      code.3522 = code.3521 + 1;
      code = code.3522;
      *code.3521 = 36;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3523 = code.2881;
            code.3524 = code.3523 + 1;
            code = code.3524;
            D.29888 = imb.b[0];
            *code.3523 = D.29888;
            code.2881 = code;
            code.3525 = code.2881;
            code.3526 = code.3525 + 1;
            code = code.3526;
            D.29891 = imb.b[1];
            *code.3525 = D.29891;
            code.2881 = code;
            code.3527 = code.2881;
            code.3528 = code.3527 + 1;
            code = code.3528;
            D.29894 = imb.b[2];
            *code.3527 = D.29894;
            code.2881 = code;
            code.3529 = code.2881;
            code.3530 = code.3529 + 1;
            code = code.3530;
            D.29897 = imb.b[3];
            *code.3529 = D.29897;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29881>:
      <D.29874>:
      goto <D.23649>;
      <D.29867>:
      if (0 != 0) goto <D.29898>; else goto <D.29899>;
      <D.29898>:
      code.2881 = code;
      code.3531 = code.2881;
      code.3532 = code.3531 + 1;
      code = code.3532;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29902 = D.28915 | 32;
      D.29903 = (unsigned char) D.29902;
      *code.3531 = D.29903;
      goto <D.23649>;
      <D.29899>:
      if (1 != 0) goto <D.29904>; else goto <D.29905>;
      <D.29904>:
      code.2881 = code;
      code.3533 = code.2881;
      code.3534 = code.3533 + 1;
      code = code.3534;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29908 = D.28915 | 96;
      D.29909 = (unsigned char) D.29908;
      *code.3533 = D.29909;
      code.2881 = code;
      *code.2881 = 32;
      code.2881 = code;
      code.2929 = code.2881 + 1;
      code = code.2929;
      goto <D.29910>;
      <D.29905>:
      code.2881 = code;
      code.3535 = code.2881;
      code.3536 = code.3535 + 1;
      code = code.3536;
      D.28914 = (signed char) cont_reg;
      D.28915 = D.28914 & 7;
      D.29913 = D.28915 | -96;
      D.29914 = (unsigned char) D.29913;
      *code.3535 = D.29914;
      {
        union x86_imm_buf imb;

        try
          {
            imb.val = 32;
            code.2881 = code;
            code.3537 = code.2881;
            code.3538 = code.3537 + 1;
            code = code.3538;
            D.29917 = imb.b[0];
            *code.3537 = D.29917;
            code.2881 = code;
            code.3539 = code.2881;
            code.3540 = code.3539 + 1;
            code = code.3540;
            D.29920 = imb.b[1];
            *code.3539 = D.29920;
            code.2881 = code;
            code.3541 = code.2881;
            code.3542 = code.3541 + 1;
            code = code.3542;
            D.29923 = imb.b[2];
            *code.3541 = D.29923;
            code.2881 = code;
            code.3543 = code.2881;
            code.3544 = code.3543 + 1;
            code = code.3544;
            D.29926 = imb.b[3];
            *code.3543 = D.29926;
          }
        finally
          {
            imb = {CLOBBER};
          }
      }
      <D.29910>:
      <D.23649>:
      <D.29865>:
      code.2881 = code;
      code.3545 = (long int) code.2881;
      start.2880 = start;
      start.3546 = (long int) start.2880;
      D.29929 = code.3545 - start.3546;
      D.29930 = D.29929 > 64;
      D.29931 = (long int) D.29930;
      D.29932 = __builtin_expect (D.29931, 0);
      if (D.29932 != 0) goto <D.29933>; else goto <D.29934>;
      <D.29933>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exceptions-amd64.c", 1453, "(code - start) <= kMaxCodeSize");
      <D.29934>:
      kMaxCodeSize.2878 = (int) kMaxCodeSize;
      nacl_global_codeman_validate (&start, kMaxCodeSize.2878, &code);
      start.2880 = start;
      saved = start.2880;
      saved.2877 = saved;
      D.28802 = (void (*MonoContinuationRestore) (struct MonoContinuation *, int, struct MonoLMF * *)) saved.2877;
      return D.28802;
    }
  finally
    {
      code = {CLOBBER};
      start = {CLOBBER};
    }
}


mono_arch_setup_resume_sighandler_ctx (struct MonoContext * ctx, void * func)
{
  long int D.29937;
  long unsigned int D.29938;
  long unsigned int D.29939;
  long unsigned int D.29942;
  long int D.29943;
  long int func.3547;

  D.29937 = ctx->rsp;
  D.29938 = (long unsigned int) D.29937;
  D.29939 = D.29938 & 15;
  if (D.29939 == 0) goto <D.29940>; else goto <D.29941>;
  <D.29940>:
  D.29937 = ctx->rsp;
  D.29938 = (long unsigned int) D.29937;
  D.29942 = D.29938 + 18446744073709551608;
  D.29943 = (long int) D.29942;
  ctx->rsp = D.29943;
  <D.29941>:
  func.3547 = (long int) func;
  ctx->rip = func.3547;
}


