
#include "AngleInfo.h"
 
 
 
void
AngleInfo::from_batched_angle_torsions_bits_540() {
 
     assign_angle_torsion(0,175,0);
     assign_angle_torsion(5,175,0);
     assign_angle_torsion(10,175,0);
     assign_angle_torsion(15,175,0);
     assign_angle_torsion(20,175,0);
     assign_angle_torsion(25,175,0);
     assign_angle_torsion(30,175,0);
     assign_angle_torsion(35,175,0);
     assign_angle_torsion(40,175,0);
     assign_angle_torsion(45,175,0);
     assign_angle_torsion(50,175,0);
     assign_angle_torsion(55,175,0);
     assign_angle_torsion(60,175,0);
     assign_angle_torsion(65,175,0);
     assign_angle_torsion(70,175,1);
     assign_angle_torsion(75,175,0);
     assign_angle_torsion(80,175,26);
     assign_angle_torsion(85,175,53);
     assign_angle_torsion(90,175,204);
     assign_angle_torsion(95,175,197);
     assign_angle_torsion(100,175,283);
     assign_angle_torsion(105,175,545);
     assign_angle_torsion(110,175,650);
     assign_angle_torsion(115,175,756);
     assign_angle_torsion(120,175,600);
     assign_angle_torsion(125,175,469);
     assign_angle_torsion(130,175,342);
     assign_angle_torsion(135,175,300);
     assign_angle_torsion(140,175,111);
     assign_angle_torsion(145,175,32);
     assign_angle_torsion(150,175,3);
     assign_angle_torsion(155,175,0);
     assign_angle_torsion(160,175,1);
     assign_angle_torsion(165,175,1);
     assign_angle_torsion(170,175,0);
     assign_angle_torsion(175,175,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_535() {
 
     assign_angle_torsion(0,170,0);
     assign_angle_torsion(5,170,0);
     assign_angle_torsion(10,170,0);
     assign_angle_torsion(15,170,0);
     assign_angle_torsion(20,170,0);
     assign_angle_torsion(25,170,0);
     assign_angle_torsion(30,170,0);
     assign_angle_torsion(35,170,0);
     assign_angle_torsion(40,170,0);
     assign_angle_torsion(45,170,0);
     assign_angle_torsion(50,170,0);
     assign_angle_torsion(55,170,0);
     assign_angle_torsion(60,170,0);
     assign_angle_torsion(65,170,0);
     assign_angle_torsion(70,170,1);
     assign_angle_torsion(75,170,0);
     assign_angle_torsion(80,170,10);
     assign_angle_torsion(85,170,61);
     assign_angle_torsion(90,170,208);
     assign_angle_torsion(95,170,304);
     assign_angle_torsion(100,170,263);
     assign_angle_torsion(105,170,537);
     assign_angle_torsion(110,170,705);
     assign_angle_torsion(115,170,626);
     assign_angle_torsion(120,170,505);
     assign_angle_torsion(125,170,366);
     assign_angle_torsion(130,170,266);
     assign_angle_torsion(135,170,202);
     assign_angle_torsion(140,170,69);
     assign_angle_torsion(145,170,21);
     assign_angle_torsion(150,170,10);
     assign_angle_torsion(155,170,0);
     assign_angle_torsion(160,170,0);
     assign_angle_torsion(165,170,1);
     assign_angle_torsion(170,170,1);
     assign_angle_torsion(175,170,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_530() {
 
     assign_angle_torsion(0,165,0);
     assign_angle_torsion(5,165,0);
     assign_angle_torsion(10,165,0);
     assign_angle_torsion(15,165,0);
     assign_angle_torsion(20,165,0);
     assign_angle_torsion(25,165,0);
     assign_angle_torsion(30,165,0);
     assign_angle_torsion(35,165,0);
     assign_angle_torsion(40,165,0);
     assign_angle_torsion(45,165,0);
     assign_angle_torsion(50,165,0);
     assign_angle_torsion(55,165,0);
     assign_angle_torsion(60,165,0);
     assign_angle_torsion(65,165,0);
     assign_angle_torsion(70,165,2);
     assign_angle_torsion(75,165,1);
     assign_angle_torsion(80,165,11);
     assign_angle_torsion(85,165,69);
     assign_angle_torsion(90,165,253);
     assign_angle_torsion(95,165,265);
     assign_angle_torsion(100,165,256);
     assign_angle_torsion(105,165,456);
     assign_angle_torsion(110,165,591);
     assign_angle_torsion(115,165,481);
     assign_angle_torsion(120,165,398);
     assign_angle_torsion(125,165,274);
     assign_angle_torsion(130,165,203);
     assign_angle_torsion(135,165,146);
     assign_angle_torsion(140,165,64);
     assign_angle_torsion(145,165,18);
     assign_angle_torsion(150,165,16);
     assign_angle_torsion(155,165,0);
     assign_angle_torsion(160,165,0);
     assign_angle_torsion(165,165,1);
     assign_angle_torsion(170,165,0);
     assign_angle_torsion(175,165,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_525() {
 
     assign_angle_torsion(0,160,0);
     assign_angle_torsion(5,160,0);
     assign_angle_torsion(10,160,0);
     assign_angle_torsion(15,160,0);
     assign_angle_torsion(20,160,0);
     assign_angle_torsion(25,160,0);
     assign_angle_torsion(30,160,0);
     assign_angle_torsion(35,160,0);
     assign_angle_torsion(40,160,0);
     assign_angle_torsion(45,160,0);
     assign_angle_torsion(50,160,0);
     assign_angle_torsion(55,160,0);
     assign_angle_torsion(60,160,0);
     assign_angle_torsion(65,160,1);
     assign_angle_torsion(70,160,2);
     assign_angle_torsion(75,160,0);
     assign_angle_torsion(80,160,11);
     assign_angle_torsion(85,160,99);
     assign_angle_torsion(90,160,238);
     assign_angle_torsion(95,160,249);
     assign_angle_torsion(100,160,241);
     assign_angle_torsion(105,160,403);
     assign_angle_torsion(110,160,449);
     assign_angle_torsion(115,160,386);
     assign_angle_torsion(120,160,328);
     assign_angle_torsion(125,160,200);
     assign_angle_torsion(130,160,170);
     assign_angle_torsion(135,160,107);
     assign_angle_torsion(140,160,48);
     assign_angle_torsion(145,160,37);
     assign_angle_torsion(150,160,3);
     assign_angle_torsion(155,160,1);
     assign_angle_torsion(160,160,2);
     assign_angle_torsion(165,160,0);
     assign_angle_torsion(170,160,0);
     assign_angle_torsion(175,160,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_520() {
 
     assign_angle_torsion(0,155,0);
     assign_angle_torsion(5,155,0);
     assign_angle_torsion(10,155,0);
     assign_angle_torsion(15,155,0);
     assign_angle_torsion(20,155,0);
     assign_angle_torsion(25,155,0);
     assign_angle_torsion(30,155,0);
     assign_angle_torsion(35,155,0);
     assign_angle_torsion(40,155,0);
     assign_angle_torsion(45,155,0);
     assign_angle_torsion(50,155,0);
     assign_angle_torsion(55,155,0);
     assign_angle_torsion(60,155,0);
     assign_angle_torsion(65,155,1);
     assign_angle_torsion(70,155,0);
     assign_angle_torsion(75,155,1);
     assign_angle_torsion(80,155,10);
     assign_angle_torsion(85,155,103);
     assign_angle_torsion(90,155,262);
     assign_angle_torsion(95,155,300);
     assign_angle_torsion(100,155,235);
     assign_angle_torsion(105,155,341);
     assign_angle_torsion(110,155,295);
     assign_angle_torsion(115,155,277);
     assign_angle_torsion(120,155,216);
     assign_angle_torsion(125,155,128);
     assign_angle_torsion(130,155,112);
     assign_angle_torsion(135,155,57);
     assign_angle_torsion(140,155,34);
     assign_angle_torsion(145,155,11);
     assign_angle_torsion(150,155,4);
     assign_angle_torsion(155,155,0);
     assign_angle_torsion(160,155,0);
     assign_angle_torsion(165,155,0);
     assign_angle_torsion(170,155,0);
     assign_angle_torsion(175,155,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_515() {
 
     assign_angle_torsion(0,150,0);
     assign_angle_torsion(5,150,0);
     assign_angle_torsion(10,150,0);
     assign_angle_torsion(15,150,0);
     assign_angle_torsion(20,150,0);
     assign_angle_torsion(25,150,0);
     assign_angle_torsion(30,150,0);
     assign_angle_torsion(35,150,0);
     assign_angle_torsion(40,150,0);
     assign_angle_torsion(45,150,0);
     assign_angle_torsion(50,150,0);
     assign_angle_torsion(55,150,0);
     assign_angle_torsion(60,150,0);
     assign_angle_torsion(65,150,1);
     assign_angle_torsion(70,150,1);
     assign_angle_torsion(75,150,0);
     assign_angle_torsion(80,150,12);
     assign_angle_torsion(85,150,93);
     assign_angle_torsion(90,150,290);
     assign_angle_torsion(95,150,387);
     assign_angle_torsion(100,150,288);
     assign_angle_torsion(105,150,254);
     assign_angle_torsion(110,150,234);
     assign_angle_torsion(115,150,261);
     assign_angle_torsion(120,150,176);
     assign_angle_torsion(125,150,123);
     assign_angle_torsion(130,150,118);
     assign_angle_torsion(135,150,64);
     assign_angle_torsion(140,150,16);
     assign_angle_torsion(145,150,7);
     assign_angle_torsion(150,150,1);
     assign_angle_torsion(155,150,0);
     assign_angle_torsion(160,150,0);
     assign_angle_torsion(165,150,0);
     assign_angle_torsion(170,150,0);
     assign_angle_torsion(175,150,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_510() {
 
     assign_angle_torsion(0,145,0);
     assign_angle_torsion(5,145,0);
     assign_angle_torsion(10,145,0);
     assign_angle_torsion(15,145,0);
     assign_angle_torsion(20,145,0);
     assign_angle_torsion(25,145,0);
     assign_angle_torsion(30,145,0);
     assign_angle_torsion(35,145,0);
     assign_angle_torsion(40,145,0);
     assign_angle_torsion(45,145,0);
     assign_angle_torsion(50,145,0);
     assign_angle_torsion(55,145,0);
     assign_angle_torsion(60,145,0);
     assign_angle_torsion(65,145,3);
     assign_angle_torsion(70,145,0);
     assign_angle_torsion(75,145,0);
     assign_angle_torsion(80,145,10);
     assign_angle_torsion(85,145,101);
     assign_angle_torsion(90,145,326);
     assign_angle_torsion(95,145,387);
     assign_angle_torsion(100,145,246);
     assign_angle_torsion(105,145,165);
     assign_angle_torsion(110,145,161);
     assign_angle_torsion(115,145,216);
     assign_angle_torsion(120,145,142);
     assign_angle_torsion(125,145,106);
     assign_angle_torsion(130,145,77);
     assign_angle_torsion(135,145,42);
     assign_angle_torsion(140,145,14);
     assign_angle_torsion(145,145,10);
     assign_angle_torsion(150,145,1);
     assign_angle_torsion(155,145,0);
     assign_angle_torsion(160,145,0);
     assign_angle_torsion(165,145,0);
     assign_angle_torsion(170,145,0);
     assign_angle_torsion(175,145,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_505() {
 
     assign_angle_torsion(0,140,0);
     assign_angle_torsion(5,140,0);
     assign_angle_torsion(10,140,0);
     assign_angle_torsion(15,140,0);
     assign_angle_torsion(20,140,0);
     assign_angle_torsion(25,140,0);
     assign_angle_torsion(30,140,0);
     assign_angle_torsion(35,140,0);
     assign_angle_torsion(40,140,0);
     assign_angle_torsion(45,140,0);
     assign_angle_torsion(50,140,0);
     assign_angle_torsion(55,140,0);
     assign_angle_torsion(60,140,0);
     assign_angle_torsion(65,140,0);
     assign_angle_torsion(70,140,0);
     assign_angle_torsion(75,140,0);
     assign_angle_torsion(80,140,14);
     assign_angle_torsion(85,140,89);
     assign_angle_torsion(90,140,408);
     assign_angle_torsion(95,140,506);
     assign_angle_torsion(100,140,267);
     assign_angle_torsion(105,140,167);
     assign_angle_torsion(110,140,139);
     assign_angle_torsion(115,140,128);
     assign_angle_torsion(120,140,109);
     assign_angle_torsion(125,140,93);
     assign_angle_torsion(130,140,40);
     assign_angle_torsion(135,140,17);
     assign_angle_torsion(140,140,15);
     assign_angle_torsion(145,140,5);
     assign_angle_torsion(150,140,0);
     assign_angle_torsion(155,140,0);
     assign_angle_torsion(160,140,0);
     assign_angle_torsion(165,140,0);
     assign_angle_torsion(170,140,0);
     assign_angle_torsion(175,140,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_500() {
 
     assign_angle_torsion(0,135,0);
     assign_angle_torsion(5,135,0);
     assign_angle_torsion(10,135,0);
     assign_angle_torsion(15,135,0);
     assign_angle_torsion(20,135,0);
     assign_angle_torsion(25,135,0);
     assign_angle_torsion(30,135,0);
     assign_angle_torsion(35,135,0);
     assign_angle_torsion(40,135,0);
     assign_angle_torsion(45,135,0);
     assign_angle_torsion(50,135,0);
     assign_angle_torsion(55,135,0);
     assign_angle_torsion(60,135,1);
     assign_angle_torsion(65,135,1);
     assign_angle_torsion(70,135,0);
     assign_angle_torsion(75,135,0);
     assign_angle_torsion(80,135,6);
     assign_angle_torsion(85,135,120);
     assign_angle_torsion(90,135,465);
     assign_angle_torsion(95,135,567);
     assign_angle_torsion(100,135,288);
     assign_angle_torsion(105,135,113);
     assign_angle_torsion(110,135,95);
     assign_angle_torsion(115,135,122);
     assign_angle_torsion(120,135,89);
     assign_angle_torsion(125,135,85);
     assign_angle_torsion(130,135,34);
     assign_angle_torsion(135,135,24);
     assign_angle_torsion(140,135,9);
     assign_angle_torsion(145,135,5);
     assign_angle_torsion(150,135,1);
     assign_angle_torsion(155,135,0);
     assign_angle_torsion(160,135,0);
     assign_angle_torsion(165,135,1);
     assign_angle_torsion(170,135,0);
     assign_angle_torsion(175,135,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_495() {
 
     assign_angle_torsion(0,130,0);
     assign_angle_torsion(5,130,0);
     assign_angle_torsion(10,130,0);
     assign_angle_torsion(15,130,0);
     assign_angle_torsion(20,130,0);
     assign_angle_torsion(25,130,0);
     assign_angle_torsion(30,130,0);
     assign_angle_torsion(35,130,0);
     assign_angle_torsion(40,130,0);
     assign_angle_torsion(45,130,0);
     assign_angle_torsion(50,130,0);
     assign_angle_torsion(55,130,1);
     assign_angle_torsion(60,130,1);
     assign_angle_torsion(65,130,1);
     assign_angle_torsion(70,130,0);
     assign_angle_torsion(75,130,1);
     assign_angle_torsion(80,130,4);
     assign_angle_torsion(85,130,98);
     assign_angle_torsion(90,130,460);
     assign_angle_torsion(95,130,615);
     assign_angle_torsion(100,130,251);
     assign_angle_torsion(105,130,90);
     assign_angle_torsion(110,130,81);
     assign_angle_torsion(115,130,65);
     assign_angle_torsion(120,130,68);
     assign_angle_torsion(125,130,35);
     assign_angle_torsion(130,130,28);
     assign_angle_torsion(135,130,17);
     assign_angle_torsion(140,130,14);
     assign_angle_torsion(145,130,3);
     assign_angle_torsion(150,130,4);
     assign_angle_torsion(155,130,0);
     assign_angle_torsion(160,130,0);
     assign_angle_torsion(165,130,1);
     assign_angle_torsion(170,130,0);
     assign_angle_torsion(175,130,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_490() {
 
     assign_angle_torsion(0,125,0);
     assign_angle_torsion(5,125,0);
     assign_angle_torsion(10,125,0);
     assign_angle_torsion(15,125,0);
     assign_angle_torsion(20,125,0);
     assign_angle_torsion(25,125,0);
     assign_angle_torsion(30,125,0);
     assign_angle_torsion(35,125,0);
     assign_angle_torsion(40,125,0);
     assign_angle_torsion(45,125,0);
     assign_angle_torsion(50,125,0);
     assign_angle_torsion(55,125,0);
     assign_angle_torsion(60,125,0);
     assign_angle_torsion(65,125,1);
     assign_angle_torsion(70,125,3);
     assign_angle_torsion(75,125,0);
     assign_angle_torsion(80,125,8);
     assign_angle_torsion(85,125,127);
     assign_angle_torsion(90,125,578);
     assign_angle_torsion(95,125,768);
     assign_angle_torsion(100,125,314);
     assign_angle_torsion(105,125,102);
     assign_angle_torsion(110,125,42);
     assign_angle_torsion(115,125,40);
     assign_angle_torsion(120,125,43);
     assign_angle_torsion(125,125,37);
     assign_angle_torsion(130,125,27);
     assign_angle_torsion(135,125,16);
     assign_angle_torsion(140,125,12);
     assign_angle_torsion(145,125,2);
     assign_angle_torsion(150,125,0);
     assign_angle_torsion(155,125,0);
     assign_angle_torsion(160,125,0);
     assign_angle_torsion(165,125,0);
     assign_angle_torsion(170,125,0);
     assign_angle_torsion(175,125,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_485() {
 
     assign_angle_torsion(0,120,0);
     assign_angle_torsion(5,120,0);
     assign_angle_torsion(10,120,0);
     assign_angle_torsion(15,120,0);
     assign_angle_torsion(20,120,0);
     assign_angle_torsion(25,120,0);
     assign_angle_torsion(30,120,0);
     assign_angle_torsion(35,120,0);
     assign_angle_torsion(40,120,0);
     assign_angle_torsion(45,120,0);
     assign_angle_torsion(50,120,0);
     assign_angle_torsion(55,120,0);
     assign_angle_torsion(60,120,0);
     assign_angle_torsion(65,120,0);
     assign_angle_torsion(70,120,4);
     assign_angle_torsion(75,120,1);
     assign_angle_torsion(80,120,10);
     assign_angle_torsion(85,120,99);
     assign_angle_torsion(90,120,676);
     assign_angle_torsion(95,120,719);
     assign_angle_torsion(100,120,307);
     assign_angle_torsion(105,120,140);
     assign_angle_torsion(110,120,50);
     assign_angle_torsion(115,120,32);
     assign_angle_torsion(120,120,29);
     assign_angle_torsion(125,120,45);
     assign_angle_torsion(130,120,18);
     assign_angle_torsion(135,120,23);
     assign_angle_torsion(140,120,28);
     assign_angle_torsion(145,120,3);
     assign_angle_torsion(150,120,0);
     assign_angle_torsion(155,120,1);
     assign_angle_torsion(160,120,0);
     assign_angle_torsion(165,120,0);
     assign_angle_torsion(170,120,0);
     assign_angle_torsion(175,120,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_480() {
 
     assign_angle_torsion(0,115,0);
     assign_angle_torsion(5,115,0);
     assign_angle_torsion(10,115,0);
     assign_angle_torsion(15,115,0);
     assign_angle_torsion(20,115,0);
     assign_angle_torsion(25,115,0);
     assign_angle_torsion(30,115,0);
     assign_angle_torsion(35,115,0);
     assign_angle_torsion(40,115,0);
     assign_angle_torsion(45,115,0);
     assign_angle_torsion(50,115,0);
     assign_angle_torsion(55,115,0);
     assign_angle_torsion(60,115,0);
     assign_angle_torsion(65,115,0);
     assign_angle_torsion(70,115,1);
     assign_angle_torsion(75,115,2);
     assign_angle_torsion(80,115,13);
     assign_angle_torsion(85,115,134);
     assign_angle_torsion(90,115,657);
     assign_angle_torsion(95,115,884);
     assign_angle_torsion(100,115,300);
     assign_angle_torsion(105,115,154);
     assign_angle_torsion(110,115,48);
     assign_angle_torsion(115,115,38);
     assign_angle_torsion(120,115,24);
     assign_angle_torsion(125,115,26);
     assign_angle_torsion(130,115,16);
     assign_angle_torsion(135,115,15);
     assign_angle_torsion(140,115,25);
     assign_angle_torsion(145,115,2);
     assign_angle_torsion(150,115,3);
     assign_angle_torsion(155,115,0);
     assign_angle_torsion(160,115,1);
     assign_angle_torsion(165,115,0);
     assign_angle_torsion(170,115,0);
     assign_angle_torsion(175,115,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_475() {
 
     assign_angle_torsion(0,110,0);
     assign_angle_torsion(5,110,0);
     assign_angle_torsion(10,110,0);
     assign_angle_torsion(15,110,0);
     assign_angle_torsion(20,110,0);
     assign_angle_torsion(25,110,0);
     assign_angle_torsion(30,110,0);
     assign_angle_torsion(35,110,1);
     assign_angle_torsion(40,110,0);
     assign_angle_torsion(45,110,0);
     assign_angle_torsion(50,110,0);
     assign_angle_torsion(55,110,0);
     assign_angle_torsion(60,110,0);
     assign_angle_torsion(65,110,3);
     assign_angle_torsion(70,110,0);
     assign_angle_torsion(75,110,2);
     assign_angle_torsion(80,110,13);
     assign_angle_torsion(85,110,97);
     assign_angle_torsion(90,110,712);
     assign_angle_torsion(95,110,947);
     assign_angle_torsion(100,110,323);
     assign_angle_torsion(105,110,134);
     assign_angle_torsion(110,110,57);
     assign_angle_torsion(115,110,26);
     assign_angle_torsion(120,110,25);
     assign_angle_torsion(125,110,19);
     assign_angle_torsion(130,110,16);
     assign_angle_torsion(135,110,13);
     assign_angle_torsion(140,110,21);
     assign_angle_torsion(145,110,5);
     assign_angle_torsion(150,110,1);
     assign_angle_torsion(155,110,0);
     assign_angle_torsion(160,110,0);
     assign_angle_torsion(165,110,0);
     assign_angle_torsion(170,110,0);
     assign_angle_torsion(175,110,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_470() {
 
     assign_angle_torsion(0,105,0);
     assign_angle_torsion(5,105,0);
     assign_angle_torsion(10,105,0);
     assign_angle_torsion(15,105,0);
     assign_angle_torsion(20,105,0);
     assign_angle_torsion(25,105,0);
     assign_angle_torsion(30,105,0);
     assign_angle_torsion(35,105,1);
     assign_angle_torsion(40,105,0);
     assign_angle_torsion(45,105,0);
     assign_angle_torsion(50,105,0);
     assign_angle_torsion(55,105,0);
     assign_angle_torsion(60,105,2);
     assign_angle_torsion(65,105,1);
     assign_angle_torsion(70,105,0);
     assign_angle_torsion(75,105,4);
     assign_angle_torsion(80,105,14);
     assign_angle_torsion(85,105,110);
     assign_angle_torsion(90,105,674);
     assign_angle_torsion(95,105,912);
     assign_angle_torsion(100,105,300);
     assign_angle_torsion(105,105,122);
     assign_angle_torsion(110,105,67);
     assign_angle_torsion(115,105,25);
     assign_angle_torsion(120,105,26);
     assign_angle_torsion(125,105,30);
     assign_angle_torsion(130,105,22);
     assign_angle_torsion(135,105,16);
     assign_angle_torsion(140,105,14);
     assign_angle_torsion(145,105,5);
     assign_angle_torsion(150,105,0);
     assign_angle_torsion(155,105,0);
     assign_angle_torsion(160,105,0);
     assign_angle_torsion(165,105,0);
     assign_angle_torsion(170,105,0);
     assign_angle_torsion(175,105,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_465() {
 
     assign_angle_torsion(0,100,0);
     assign_angle_torsion(5,100,0);
     assign_angle_torsion(10,100,0);
     assign_angle_torsion(15,100,0);
     assign_angle_torsion(20,100,0);
     assign_angle_torsion(25,100,0);
     assign_angle_torsion(30,100,0);
     assign_angle_torsion(35,100,0);
     assign_angle_torsion(40,100,0);
     assign_angle_torsion(45,100,0);
     assign_angle_torsion(50,100,0);
     assign_angle_torsion(55,100,0);
     assign_angle_torsion(60,100,0);
     assign_angle_torsion(65,100,0);
     assign_angle_torsion(70,100,2);
     assign_angle_torsion(75,100,1);
     assign_angle_torsion(80,100,15);
     assign_angle_torsion(85,100,132);
     assign_angle_torsion(90,100,671);
     assign_angle_torsion(95,100,828);
     assign_angle_torsion(100,100,356);
     assign_angle_torsion(105,100,197);
     assign_angle_torsion(110,100,68);
     assign_angle_torsion(115,100,38);
     assign_angle_torsion(120,100,14);
     assign_angle_torsion(125,100,20);
     assign_angle_torsion(130,100,30);
     assign_angle_torsion(135,100,18);
     assign_angle_torsion(140,100,12);
     assign_angle_torsion(145,100,5);
     assign_angle_torsion(150,100,3);
     assign_angle_torsion(155,100,1);
     assign_angle_torsion(160,100,0);
     assign_angle_torsion(165,100,0);
     assign_angle_torsion(170,100,0);
     assign_angle_torsion(175,100,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_460() {
 
     assign_angle_torsion(0,95,0);
     assign_angle_torsion(5,95,0);
     assign_angle_torsion(10,95,0);
     assign_angle_torsion(15,95,0);
     assign_angle_torsion(20,95,0);
     assign_angle_torsion(25,95,0);
     assign_angle_torsion(30,95,1);
     assign_angle_torsion(35,95,0);
     assign_angle_torsion(40,95,0);
     assign_angle_torsion(45,95,0);
     assign_angle_torsion(50,95,0);
     assign_angle_torsion(55,95,0);
     assign_angle_torsion(60,95,1);
     assign_angle_torsion(65,95,0);
     assign_angle_torsion(70,95,1);
     assign_angle_torsion(75,95,6);
     assign_angle_torsion(80,95,12);
     assign_angle_torsion(85,95,131);
     assign_angle_torsion(90,95,709);
     assign_angle_torsion(95,95,611);
     assign_angle_torsion(100,95,286);
     assign_angle_torsion(105,95,158);
     assign_angle_torsion(110,95,65);
     assign_angle_torsion(115,95,50);
     assign_angle_torsion(120,95,30);
     assign_angle_torsion(125,95,19);
     assign_angle_torsion(130,95,37);
     assign_angle_torsion(135,95,12);
     assign_angle_torsion(140,95,9);
     assign_angle_torsion(145,95,1);
     assign_angle_torsion(150,95,1);
     assign_angle_torsion(155,95,0);
     assign_angle_torsion(160,95,0);
     assign_angle_torsion(165,95,0);
     assign_angle_torsion(170,95,0);
     assign_angle_torsion(175,95,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_455() {
 
     assign_angle_torsion(0,90,0);
     assign_angle_torsion(5,90,0);
     assign_angle_torsion(10,90,0);
     assign_angle_torsion(15,90,0);
     assign_angle_torsion(20,90,0);
     assign_angle_torsion(25,90,0);
     assign_angle_torsion(30,90,0);
     assign_angle_torsion(35,90,0);
     assign_angle_torsion(40,90,0);
     assign_angle_torsion(45,90,0);
     assign_angle_torsion(50,90,0);
     assign_angle_torsion(55,90,0);
     assign_angle_torsion(60,90,2);
     assign_angle_torsion(65,90,0);
     assign_angle_torsion(70,90,2);
     assign_angle_torsion(75,90,1);
     assign_angle_torsion(80,90,10);
     assign_angle_torsion(85,90,162);
     assign_angle_torsion(90,90,633);
     assign_angle_torsion(95,90,591);
     assign_angle_torsion(100,90,256);
     assign_angle_torsion(105,90,128);
     assign_angle_torsion(110,90,80);
     assign_angle_torsion(115,90,42);
     assign_angle_torsion(120,90,14);
     assign_angle_torsion(125,90,13);
     assign_angle_torsion(130,90,15);
     assign_angle_torsion(135,90,22);
     assign_angle_torsion(140,90,33);
     assign_angle_torsion(145,90,2);
     assign_angle_torsion(150,90,1);
     assign_angle_torsion(155,90,0);
     assign_angle_torsion(160,90,0);
     assign_angle_torsion(165,90,0);
     assign_angle_torsion(170,90,0);
     assign_angle_torsion(175,90,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_450() {
 
     assign_angle_torsion(0,85,0);
     assign_angle_torsion(5,85,0);
     assign_angle_torsion(10,85,0);
     assign_angle_torsion(15,85,0);
     assign_angle_torsion(20,85,0);
     assign_angle_torsion(25,85,0);
     assign_angle_torsion(30,85,0);
     assign_angle_torsion(35,85,0);
     assign_angle_torsion(40,85,0);
     assign_angle_torsion(45,85,0);
     assign_angle_torsion(50,85,0);
     assign_angle_torsion(55,85,0);
     assign_angle_torsion(60,85,3);
     assign_angle_torsion(65,85,2);
     assign_angle_torsion(70,85,2);
     assign_angle_torsion(75,85,3);
     assign_angle_torsion(80,85,29);
     assign_angle_torsion(85,85,212);
     assign_angle_torsion(90,85,602);
     assign_angle_torsion(95,85,508);
     assign_angle_torsion(100,85,240);
     assign_angle_torsion(105,85,140);
     assign_angle_torsion(110,85,70);
     assign_angle_torsion(115,85,55);
     assign_angle_torsion(120,85,11);
     assign_angle_torsion(125,85,26);
     assign_angle_torsion(130,85,20);
     assign_angle_torsion(135,85,15);
     assign_angle_torsion(140,85,18);
     assign_angle_torsion(145,85,5);
     assign_angle_torsion(150,85,0);
     assign_angle_torsion(155,85,0);
     assign_angle_torsion(160,85,0);
     assign_angle_torsion(165,85,0);
     assign_angle_torsion(170,85,0);
     assign_angle_torsion(175,85,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_445() {
 
     assign_angle_torsion(0,80,0);
     assign_angle_torsion(5,80,0);
     assign_angle_torsion(10,80,0);
     assign_angle_torsion(15,80,0);
     assign_angle_torsion(20,80,0);
     assign_angle_torsion(25,80,0);
     assign_angle_torsion(30,80,0);
     assign_angle_torsion(35,80,0);
     assign_angle_torsion(40,80,0);
     assign_angle_torsion(45,80,0);
     assign_angle_torsion(50,80,0);
     assign_angle_torsion(55,80,0);
     assign_angle_torsion(60,80,0);
     assign_angle_torsion(65,80,1);
     assign_angle_torsion(70,80,0);
     assign_angle_torsion(75,80,4);
     assign_angle_torsion(80,80,56);
     assign_angle_torsion(85,80,334);
     assign_angle_torsion(90,80,783);
     assign_angle_torsion(95,80,505);
     assign_angle_torsion(100,80,217);
     assign_angle_torsion(105,80,143);
     assign_angle_torsion(110,80,51);
     assign_angle_torsion(115,80,24);
     assign_angle_torsion(120,80,14);
     assign_angle_torsion(125,80,17);
     assign_angle_torsion(130,80,11);
     assign_angle_torsion(135,80,19);
     assign_angle_torsion(140,80,19);
     assign_angle_torsion(145,80,2);
     assign_angle_torsion(150,80,5);
     assign_angle_torsion(155,80,0);
     assign_angle_torsion(160,80,0);
     assign_angle_torsion(165,80,1);
     assign_angle_torsion(170,80,0);
     assign_angle_torsion(175,80,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_440() {
 
     assign_angle_torsion(0,75,0);
     assign_angle_torsion(5,75,0);
     assign_angle_torsion(10,75,0);
     assign_angle_torsion(15,75,0);
     assign_angle_torsion(20,75,0);
     assign_angle_torsion(25,75,0);
     assign_angle_torsion(30,75,0);
     assign_angle_torsion(35,75,0);
     assign_angle_torsion(40,75,0);
     assign_angle_torsion(45,75,0);
     assign_angle_torsion(50,75,1);
     assign_angle_torsion(55,75,1);
     assign_angle_torsion(60,75,2);
     assign_angle_torsion(65,75,0);
     assign_angle_torsion(70,75,0);
     assign_angle_torsion(75,75,17);
     assign_angle_torsion(80,75,85);
     assign_angle_torsion(85,75,523);
     assign_angle_torsion(90,75,967);
     assign_angle_torsion(95,75,473);
     assign_angle_torsion(100,75,202);
     assign_angle_torsion(105,75,144);
     assign_angle_torsion(110,75,60);
     assign_angle_torsion(115,75,37);
     assign_angle_torsion(120,75,17);
     assign_angle_torsion(125,75,16);
     assign_angle_torsion(130,75,15);
     assign_angle_torsion(135,75,7);
     assign_angle_torsion(140,75,24);
     assign_angle_torsion(145,75,13);
     assign_angle_torsion(150,75,3);
     assign_angle_torsion(155,75,0);
     assign_angle_torsion(160,75,0);
     assign_angle_torsion(165,75,0);
     assign_angle_torsion(170,75,1);
     assign_angle_torsion(175,75,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_435() {
 
     assign_angle_torsion(0,70,0);
     assign_angle_torsion(5,70,0);
     assign_angle_torsion(10,70,0);
     assign_angle_torsion(15,70,0);
     assign_angle_torsion(20,70,0);
     assign_angle_torsion(25,70,0);
     assign_angle_torsion(30,70,0);
     assign_angle_torsion(35,70,0);
     assign_angle_torsion(40,70,0);
     assign_angle_torsion(45,70,0);
     assign_angle_torsion(50,70,0);
     assign_angle_torsion(55,70,1);
     assign_angle_torsion(60,70,0);
     assign_angle_torsion(65,70,0);
     assign_angle_torsion(70,70,1);
     assign_angle_torsion(75,70,13);
     assign_angle_torsion(80,70,132);
     assign_angle_torsion(85,70,933);
     assign_angle_torsion(90,70,1265);
     assign_angle_torsion(95,70,537);
     assign_angle_torsion(100,70,262);
     assign_angle_torsion(105,70,117);
     assign_angle_torsion(110,70,57);
     assign_angle_torsion(115,70,15);
     assign_angle_torsion(120,70,18);
     assign_angle_torsion(125,70,29);
     assign_angle_torsion(130,70,20);
     assign_angle_torsion(135,70,11);
     assign_angle_torsion(140,70,26);
     assign_angle_torsion(145,70,19);
     assign_angle_torsion(150,70,2);
     assign_angle_torsion(155,70,0);
     assign_angle_torsion(160,70,0);
     assign_angle_torsion(165,70,0);
     assign_angle_torsion(170,70,0);
     assign_angle_torsion(175,70,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_430() {
 
     assign_angle_torsion(0,65,0);
     assign_angle_torsion(5,65,0);
     assign_angle_torsion(10,65,0);
     assign_angle_torsion(15,65,0);
     assign_angle_torsion(20,65,0);
     assign_angle_torsion(25,65,0);
     assign_angle_torsion(30,65,0);
     assign_angle_torsion(35,65,0);
     assign_angle_torsion(40,65,0);
     assign_angle_torsion(45,65,0);
     assign_angle_torsion(50,65,0);
     assign_angle_torsion(55,65,0);
     assign_angle_torsion(60,65,0);
     assign_angle_torsion(65,65,0);
     assign_angle_torsion(70,65,0);
     assign_angle_torsion(75,65,8);
     assign_angle_torsion(80,65,132);
     assign_angle_torsion(85,65,1465);
     assign_angle_torsion(90,65,2037);
     assign_angle_torsion(95,65,593);
     assign_angle_torsion(100,65,247);
     assign_angle_torsion(105,65,152);
     assign_angle_torsion(110,65,65);
     assign_angle_torsion(115,65,28);
     assign_angle_torsion(120,65,13);
     assign_angle_torsion(125,65,13);
     assign_angle_torsion(130,65,14);
     assign_angle_torsion(135,65,22);
     assign_angle_torsion(140,65,22);
     assign_angle_torsion(145,65,6);
     assign_angle_torsion(150,65,3);
     assign_angle_torsion(155,65,2);
     assign_angle_torsion(160,65,1);
     assign_angle_torsion(165,65,0);
     assign_angle_torsion(170,65,0);
     assign_angle_torsion(175,65,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_425() {
 
     assign_angle_torsion(0,60,0);
     assign_angle_torsion(5,60,0);
     assign_angle_torsion(10,60,0);
     assign_angle_torsion(15,60,0);
     assign_angle_torsion(20,60,0);
     assign_angle_torsion(25,60,0);
     assign_angle_torsion(30,60,0);
     assign_angle_torsion(35,60,0);
     assign_angle_torsion(40,60,1);
     assign_angle_torsion(45,60,1);
     assign_angle_torsion(50,60,0);
     assign_angle_torsion(55,60,0);
     assign_angle_torsion(60,60,1);
     assign_angle_torsion(65,60,0);
     assign_angle_torsion(70,60,2);
     assign_angle_torsion(75,60,11);
     assign_angle_torsion(80,60,135);
     assign_angle_torsion(85,60,2049);
     assign_angle_torsion(90,60,3238);
     assign_angle_torsion(95,60,873);
     assign_angle_torsion(100,60,284);
     assign_angle_torsion(105,60,126);
     assign_angle_torsion(110,60,67);
     assign_angle_torsion(115,60,52);
     assign_angle_torsion(120,60,23);
     assign_angle_torsion(125,60,18);
     assign_angle_torsion(130,60,28);
     assign_angle_torsion(135,60,10);
     assign_angle_torsion(140,60,20);
     assign_angle_torsion(145,60,6);
     assign_angle_torsion(150,60,4);
     assign_angle_torsion(155,60,0);
     assign_angle_torsion(160,60,1);
     assign_angle_torsion(165,60,0);
     assign_angle_torsion(170,60,0);
     assign_angle_torsion(175,60,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_420() {
 
     assign_angle_torsion(0,55,0);
     assign_angle_torsion(5,55,0);
     assign_angle_torsion(10,55,0);
     assign_angle_torsion(15,55,0);
     assign_angle_torsion(20,55,0);
     assign_angle_torsion(25,55,0);
     assign_angle_torsion(30,55,0);
     assign_angle_torsion(35,55,0);
     assign_angle_torsion(40,55,0);
     assign_angle_torsion(45,55,3);
     assign_angle_torsion(50,55,1);
     assign_angle_torsion(55,55,0);
     assign_angle_torsion(60,55,0);
     assign_angle_torsion(65,55,0);
     assign_angle_torsion(70,55,3);
     assign_angle_torsion(75,55,7);
     assign_angle_torsion(80,55,159);
     assign_angle_torsion(85,55,3505);
     assign_angle_torsion(90,55,6791);
     assign_angle_torsion(95,55,1675);
     assign_angle_torsion(100,55,354);
     assign_angle_torsion(105,55,107);
     assign_angle_torsion(110,55,74);
     assign_angle_torsion(115,55,34);
     assign_angle_torsion(120,55,35);
     assign_angle_torsion(125,55,22);
     assign_angle_torsion(130,55,29);
     assign_angle_torsion(135,55,23);
     assign_angle_torsion(140,55,33);
     assign_angle_torsion(145,55,6);
     assign_angle_torsion(150,55,5);
     assign_angle_torsion(155,55,0);
     assign_angle_torsion(160,55,1);
     assign_angle_torsion(165,55,0);
     assign_angle_torsion(170,55,0);
     assign_angle_torsion(175,55,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_415() {
 
     assign_angle_torsion(0,50,0);
     assign_angle_torsion(5,50,0);
     assign_angle_torsion(10,50,0);
     assign_angle_torsion(15,50,0);
     assign_angle_torsion(20,50,0);
     assign_angle_torsion(25,50,0);
     assign_angle_torsion(30,50,0);
     assign_angle_torsion(35,50,0);
     assign_angle_torsion(40,50,0);
     assign_angle_torsion(45,50,0);
     assign_angle_torsion(50,50,0);
     assign_angle_torsion(55,50,0);
     assign_angle_torsion(60,50,1);
     assign_angle_torsion(65,50,1);
     assign_angle_torsion(70,50,3);
     assign_angle_torsion(75,50,7);
     assign_angle_torsion(80,50,143);
     assign_angle_torsion(85,50,6578);
     assign_angle_torsion(90,50,19674);
     assign_angle_torsion(95,50,2819);
     assign_angle_torsion(100,50,465);
     assign_angle_torsion(105,50,121);
     assign_angle_torsion(110,50,71);
     assign_angle_torsion(115,50,31);
     assign_angle_torsion(120,50,29);
     assign_angle_torsion(125,50,38);
     assign_angle_torsion(130,50,17);
     assign_angle_torsion(135,50,21);
     assign_angle_torsion(140,50,28);
     assign_angle_torsion(145,50,6);
     assign_angle_torsion(150,50,2);
     assign_angle_torsion(155,50,1);
     assign_angle_torsion(160,50,0);
     assign_angle_torsion(165,50,0);
     assign_angle_torsion(170,50,0);
     assign_angle_torsion(175,50,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_410() {
 
     assign_angle_torsion(0,45,0);
     assign_angle_torsion(5,45,0);
     assign_angle_torsion(10,45,0);
     assign_angle_torsion(15,45,0);
     assign_angle_torsion(20,45,0);
     assign_angle_torsion(25,45,0);
     assign_angle_torsion(30,45,0);
     assign_angle_torsion(35,45,0);
     assign_angle_torsion(40,45,0);
     assign_angle_torsion(45,45,0);
     assign_angle_torsion(50,45,0);
     assign_angle_torsion(55,45,0);
     assign_angle_torsion(60,45,0);
     assign_angle_torsion(65,45,0);
     assign_angle_torsion(70,45,1);
     assign_angle_torsion(75,45,5);
     assign_angle_torsion(80,45,115);
     assign_angle_torsion(85,45,5829);
     assign_angle_torsion(90,45,23520);
     assign_angle_torsion(95,45,4319);
     assign_angle_torsion(100,45,591);
     assign_angle_torsion(105,45,152);
     assign_angle_torsion(110,45,73);
     assign_angle_torsion(115,45,35);
     assign_angle_torsion(120,45,48);
     assign_angle_torsion(125,45,35);
     assign_angle_torsion(130,45,33);
     assign_angle_torsion(135,45,29);
     assign_angle_torsion(140,45,40);
     assign_angle_torsion(145,45,10);
     assign_angle_torsion(150,45,4);
     assign_angle_torsion(155,45,1);
     assign_angle_torsion(160,45,0);
     assign_angle_torsion(165,45,0);
     assign_angle_torsion(170,45,0);
     assign_angle_torsion(175,45,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_405() {
 
     assign_angle_torsion(0,40,0);
     assign_angle_torsion(5,40,0);
     assign_angle_torsion(10,40,0);
     assign_angle_torsion(15,40,0);
     assign_angle_torsion(20,40,0);
     assign_angle_torsion(25,40,0);
     assign_angle_torsion(30,40,0);
     assign_angle_torsion(35,40,0);
     assign_angle_torsion(40,40,0);
     assign_angle_torsion(45,40,0);
     assign_angle_torsion(50,40,2);
     assign_angle_torsion(55,40,0);
     assign_angle_torsion(60,40,0);
     assign_angle_torsion(65,40,1);
     assign_angle_torsion(70,40,1);
     assign_angle_torsion(75,40,9);
     assign_angle_torsion(80,40,78);
     assign_angle_torsion(85,40,1995);
     assign_angle_torsion(90,40,7762);
     assign_angle_torsion(95,40,3332);
     assign_angle_torsion(100,40,601);
     assign_angle_torsion(105,40,231);
     assign_angle_torsion(110,40,74);
     assign_angle_torsion(115,40,57);
     assign_angle_torsion(120,40,29);
     assign_angle_torsion(125,40,33);
     assign_angle_torsion(130,40,61);
     assign_angle_torsion(135,40,44);
     assign_angle_torsion(140,40,25);
     assign_angle_torsion(145,40,15);
     assign_angle_torsion(150,40,9);
     assign_angle_torsion(155,40,1);
     assign_angle_torsion(160,40,1);
     assign_angle_torsion(165,40,0);
     assign_angle_torsion(170,40,0);
     assign_angle_torsion(175,40,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_400() {
 
     assign_angle_torsion(0,35,0);
     assign_angle_torsion(5,35,0);
     assign_angle_torsion(10,35,0);
     assign_angle_torsion(15,35,0);
     assign_angle_torsion(20,35,0);
     assign_angle_torsion(25,35,0);
     assign_angle_torsion(30,35,0);
     assign_angle_torsion(35,35,0);
     assign_angle_torsion(40,35,0);
     assign_angle_torsion(45,35,0);
     assign_angle_torsion(50,35,0);
     assign_angle_torsion(55,35,1);
     assign_angle_torsion(60,35,0);
     assign_angle_torsion(65,35,1);
     assign_angle_torsion(70,35,3);
     assign_angle_torsion(75,35,3);
     assign_angle_torsion(80,35,46);
     assign_angle_torsion(85,35,713);
     assign_angle_torsion(90,35,2405);
     assign_angle_torsion(95,35,1498);
     assign_angle_torsion(100,35,510);
     assign_angle_torsion(105,35,253);
     assign_angle_torsion(110,35,161);
     assign_angle_torsion(115,35,64);
     assign_angle_torsion(120,35,63);
     assign_angle_torsion(125,35,40);
     assign_angle_torsion(130,35,35);
     assign_angle_torsion(135,35,47);
     assign_angle_torsion(140,35,39);
     assign_angle_torsion(145,35,13);
     assign_angle_torsion(150,35,1);
     assign_angle_torsion(155,35,1);
     assign_angle_torsion(160,35,1);
     assign_angle_torsion(165,35,0);
     assign_angle_torsion(170,35,1);
     assign_angle_torsion(175,35,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_395() {
 
     assign_angle_torsion(0,30,0);
     assign_angle_torsion(5,30,0);
     assign_angle_torsion(10,30,0);
     assign_angle_torsion(15,30,0);
     assign_angle_torsion(20,30,0);
     assign_angle_torsion(25,30,0);
     assign_angle_torsion(30,30,0);
     assign_angle_torsion(35,30,0);
     assign_angle_torsion(40,30,0);
     assign_angle_torsion(45,30,0);
     assign_angle_torsion(50,30,0);
     assign_angle_torsion(55,30,0);
     assign_angle_torsion(60,30,0);
     assign_angle_torsion(65,30,0);
     assign_angle_torsion(70,30,1);
     assign_angle_torsion(75,30,1);
     assign_angle_torsion(80,30,44);
     assign_angle_torsion(85,30,394);
     assign_angle_torsion(90,30,1113);
     assign_angle_torsion(95,30,1018);
     assign_angle_torsion(100,30,510);
     assign_angle_torsion(105,30,287);
     assign_angle_torsion(110,30,168);
     assign_angle_torsion(115,30,83);
     assign_angle_torsion(120,30,44);
     assign_angle_torsion(125,30,66);
     assign_angle_torsion(130,30,72);
     assign_angle_torsion(135,30,60);
     assign_angle_torsion(140,30,43);
     assign_angle_torsion(145,30,13);
     assign_angle_torsion(150,30,7);
     assign_angle_torsion(155,30,2);
     assign_angle_torsion(160,30,0);
     assign_angle_torsion(165,30,1);
     assign_angle_torsion(170,30,0);
     assign_angle_torsion(175,30,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_390() {
 
     assign_angle_torsion(0,25,0);
     assign_angle_torsion(5,25,0);
     assign_angle_torsion(10,25,0);
     assign_angle_torsion(15,25,0);
     assign_angle_torsion(20,25,0);
     assign_angle_torsion(25,25,0);
     assign_angle_torsion(30,25,0);
     assign_angle_torsion(35,25,0);
     assign_angle_torsion(40,25,1);
     assign_angle_torsion(45,25,0);
     assign_angle_torsion(50,25,0);
     assign_angle_torsion(55,25,0);
     assign_angle_torsion(60,25,0);
     assign_angle_torsion(65,25,1);
     assign_angle_torsion(70,25,0);
     assign_angle_torsion(75,25,4);
     assign_angle_torsion(80,25,28);
     assign_angle_torsion(85,25,313);
     assign_angle_torsion(90,25,692);
     assign_angle_torsion(95,25,652);
     assign_angle_torsion(100,25,505);
     assign_angle_torsion(105,25,311);
     assign_angle_torsion(110,25,192);
     assign_angle_torsion(115,25,119);
     assign_angle_torsion(120,25,74);
     assign_angle_torsion(125,25,44);
     assign_angle_torsion(130,25,78);
     assign_angle_torsion(135,25,55);
     assign_angle_torsion(140,25,45);
     assign_angle_torsion(145,25,16);
     assign_angle_torsion(150,25,10);
     assign_angle_torsion(155,25,2);
     assign_angle_torsion(160,25,0);
     assign_angle_torsion(165,25,0);
     assign_angle_torsion(170,25,1);
     assign_angle_torsion(175,25,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_385() {
 
     assign_angle_torsion(0,20,0);
     assign_angle_torsion(5,20,0);
     assign_angle_torsion(10,20,0);
     assign_angle_torsion(15,20,0);
     assign_angle_torsion(20,20,0);
     assign_angle_torsion(25,20,0);
     assign_angle_torsion(30,20,0);
     assign_angle_torsion(35,20,0);
     assign_angle_torsion(40,20,0);
     assign_angle_torsion(45,20,0);
     assign_angle_torsion(50,20,0);
     assign_angle_torsion(55,20,1);
     assign_angle_torsion(60,20,0);
     assign_angle_torsion(65,20,0);
     assign_angle_torsion(70,20,0);
     assign_angle_torsion(75,20,1);
     assign_angle_torsion(80,20,41);
     assign_angle_torsion(85,20,231);
     assign_angle_torsion(90,20,524);
     assign_angle_torsion(95,20,538);
     assign_angle_torsion(100,20,512);
     assign_angle_torsion(105,20,322);
     assign_angle_torsion(110,20,247);
     assign_angle_torsion(115,20,159);
     assign_angle_torsion(120,20,89);
     assign_angle_torsion(125,20,69);
     assign_angle_torsion(130,20,78);
     assign_angle_torsion(135,20,64);
     assign_angle_torsion(140,20,29);
     assign_angle_torsion(145,20,11);
     assign_angle_torsion(150,20,4);
     assign_angle_torsion(155,20,0);
     assign_angle_torsion(160,20,0);
     assign_angle_torsion(165,20,0);
     assign_angle_torsion(170,20,0);
     assign_angle_torsion(175,20,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_380() {
 
     assign_angle_torsion(0,15,0);
     assign_angle_torsion(5,15,0);
     assign_angle_torsion(10,15,0);
     assign_angle_torsion(15,15,0);
     assign_angle_torsion(20,15,0);
     assign_angle_torsion(25,15,0);
     assign_angle_torsion(30,15,0);
     assign_angle_torsion(35,15,0);
     assign_angle_torsion(40,15,1);
     assign_angle_torsion(45,15,1);
     assign_angle_torsion(50,15,2);
     assign_angle_torsion(55,15,1);
     assign_angle_torsion(60,15,1);
     assign_angle_torsion(65,15,0);
     assign_angle_torsion(70,15,0);
     assign_angle_torsion(75,15,2);
     assign_angle_torsion(80,15,14);
     assign_angle_torsion(85,15,131);
     assign_angle_torsion(90,15,341);
     assign_angle_torsion(95,15,452);
     assign_angle_torsion(100,15,435);
     assign_angle_torsion(105,15,284);
     assign_angle_torsion(110,15,307);
     assign_angle_torsion(115,15,173);
     assign_angle_torsion(120,15,77);
     assign_angle_torsion(125,15,73);
     assign_angle_torsion(130,15,41);
     assign_angle_torsion(135,15,61);
     assign_angle_torsion(140,15,28);
     assign_angle_torsion(145,15,6);
     assign_angle_torsion(150,15,2);
     assign_angle_torsion(155,15,0);
     assign_angle_torsion(160,15,0);
     assign_angle_torsion(165,15,0);
     assign_angle_torsion(170,15,0);
     assign_angle_torsion(175,15,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_375() {
 
     assign_angle_torsion(0,10,0);
     assign_angle_torsion(5,10,0);
     assign_angle_torsion(10,10,0);
     assign_angle_torsion(15,10,0);
     assign_angle_torsion(20,10,0);
     assign_angle_torsion(25,10,0);
     assign_angle_torsion(30,10,0);
     assign_angle_torsion(35,10,0);
     assign_angle_torsion(40,10,1);
     assign_angle_torsion(45,10,0);
     assign_angle_torsion(50,10,1);
     assign_angle_torsion(55,10,0);
     assign_angle_torsion(60,10,0);
     assign_angle_torsion(65,10,0);
     assign_angle_torsion(70,10,0);
     assign_angle_torsion(75,10,0);
     assign_angle_torsion(80,10,29);
     assign_angle_torsion(85,10,116);
     assign_angle_torsion(90,10,236);
     assign_angle_torsion(95,10,327);
     assign_angle_torsion(100,10,323);
     assign_angle_torsion(105,10,245);
     assign_angle_torsion(110,10,284);
     assign_angle_torsion(115,10,178);
     assign_angle_torsion(120,10,73);
     assign_angle_torsion(125,10,47);
     assign_angle_torsion(130,10,58);
     assign_angle_torsion(135,10,43);
     assign_angle_torsion(140,10,48);
     assign_angle_torsion(145,10,4);
     assign_angle_torsion(150,10,0);
     assign_angle_torsion(155,10,2);
     assign_angle_torsion(160,10,0);
     assign_angle_torsion(165,10,0);
     assign_angle_torsion(170,10,0);
     assign_angle_torsion(175,10,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_370() {
 
     assign_angle_torsion(0,5,0);
     assign_angle_torsion(5,5,0);
     assign_angle_torsion(10,5,0);
     assign_angle_torsion(15,5,0);
     assign_angle_torsion(20,5,1);
     assign_angle_torsion(25,5,0);
     assign_angle_torsion(30,5,0);
     assign_angle_torsion(35,5,0);
     assign_angle_torsion(40,5,0);
     assign_angle_torsion(45,5,0);
     assign_angle_torsion(50,5,0);
     assign_angle_torsion(55,5,1);
     assign_angle_torsion(60,5,0);
     assign_angle_torsion(65,5,0);
     assign_angle_torsion(70,5,0);
     assign_angle_torsion(75,5,1);
     assign_angle_torsion(80,5,7);
     assign_angle_torsion(85,5,68);
     assign_angle_torsion(90,5,181);
     assign_angle_torsion(95,5,220);
     assign_angle_torsion(100,5,227);
     assign_angle_torsion(105,5,227);
     assign_angle_torsion(110,5,331);
     assign_angle_torsion(115,5,189);
     assign_angle_torsion(120,5,91);
     assign_angle_torsion(125,5,42);
     assign_angle_torsion(130,5,50);
     assign_angle_torsion(135,5,43);
     assign_angle_torsion(140,5,18);
     assign_angle_torsion(145,5,7);
     assign_angle_torsion(150,5,0);
     assign_angle_torsion(155,5,0);
     assign_angle_torsion(160,5,0);
     assign_angle_torsion(165,5,0);
     assign_angle_torsion(170,5,0);
     assign_angle_torsion(175,5,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_365() {
 
     assign_angle_torsion(0,0,0);
     assign_angle_torsion(5,0,0);
     assign_angle_torsion(10,0,0);
     assign_angle_torsion(15,0,0);
     assign_angle_torsion(20,0,0);
     assign_angle_torsion(25,0,0);
     assign_angle_torsion(30,0,0);
     assign_angle_torsion(35,0,0);
     assign_angle_torsion(40,0,1);
     assign_angle_torsion(45,0,0);
     assign_angle_torsion(50,0,0);
     assign_angle_torsion(55,0,0);
     assign_angle_torsion(60,0,0);
     assign_angle_torsion(65,0,0);
     assign_angle_torsion(70,0,0);
     assign_angle_torsion(75,0,5);
     assign_angle_torsion(80,0,19);
     assign_angle_torsion(85,0,122);
     assign_angle_torsion(90,0,309);
     assign_angle_torsion(95,0,350);
     assign_angle_torsion(100,0,343);
     assign_angle_torsion(105,0,310);
     assign_angle_torsion(110,0,501);
     assign_angle_torsion(115,0,265);
     assign_angle_torsion(120,0,154);
     assign_angle_torsion(125,0,112);
     assign_angle_torsion(130,0,121);
     assign_angle_torsion(135,0,78);
     assign_angle_torsion(140,0,72);
     assign_angle_torsion(145,0,16);
     assign_angle_torsion(150,0,4);
     assign_angle_torsion(155,0,3);
     assign_angle_torsion(160,0,1);
     assign_angle_torsion(165,0,0);
     assign_angle_torsion(170,0,0);
     assign_angle_torsion(175,0,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_360() {
 
     assign_angle_torsion(0,-5,0);
     assign_angle_torsion(5,-5,0);
     assign_angle_torsion(10,-5,0);
     assign_angle_torsion(15,-5,0);
     assign_angle_torsion(20,-5,0);
     assign_angle_torsion(25,-5,0);
     assign_angle_torsion(30,-5,0);
     assign_angle_torsion(35,-5,0);
     assign_angle_torsion(40,-5,0);
     assign_angle_torsion(45,-5,0);
     assign_angle_torsion(50,-5,0);
     assign_angle_torsion(55,-5,2);
     assign_angle_torsion(60,-5,0);
     assign_angle_torsion(65,-5,0);
     assign_angle_torsion(70,-5,1);
     assign_angle_torsion(75,-5,1);
     assign_angle_torsion(80,-5,9);
     assign_angle_torsion(85,-5,26);
     assign_angle_torsion(90,-5,91);
     assign_angle_torsion(95,-5,158);
     assign_angle_torsion(100,-5,147);
     assign_angle_torsion(105,-5,103);
     assign_angle_torsion(110,-5,175);
     assign_angle_torsion(115,-5,107);
     assign_angle_torsion(120,-5,78);
     assign_angle_torsion(125,-5,75);
     assign_angle_torsion(130,-5,55);
     assign_angle_torsion(135,-5,37);
     assign_angle_torsion(140,-5,26);
     assign_angle_torsion(145,-5,9);
     assign_angle_torsion(150,-5,2);
     assign_angle_torsion(155,-5,1);
     assign_angle_torsion(160,-5,0);
     assign_angle_torsion(165,-5,1);
     assign_angle_torsion(170,-5,0);
     assign_angle_torsion(175,-5,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_355() {
 
     assign_angle_torsion(0,-10,0);
     assign_angle_torsion(5,-10,0);
     assign_angle_torsion(10,-10,0);
     assign_angle_torsion(15,-10,0);
     assign_angle_torsion(20,-10,0);
     assign_angle_torsion(25,-10,0);
     assign_angle_torsion(30,-10,0);
     assign_angle_torsion(35,-10,0);
     assign_angle_torsion(40,-10,0);
     assign_angle_torsion(45,-10,0);
     assign_angle_torsion(50,-10,0);
     assign_angle_torsion(55,-10,0);
     assign_angle_torsion(60,-10,0);
     assign_angle_torsion(65,-10,0);
     assign_angle_torsion(70,-10,2);
     assign_angle_torsion(75,-10,2);
     assign_angle_torsion(80,-10,3);
     assign_angle_torsion(85,-10,20);
     assign_angle_torsion(90,-10,79);
     assign_angle_torsion(95,-10,156);
     assign_angle_torsion(100,-10,103);
     assign_angle_torsion(105,-10,113);
     assign_angle_torsion(110,-10,154);
     assign_angle_torsion(115,-10,142);
     assign_angle_torsion(120,-10,127);
     assign_angle_torsion(125,-10,80);
     assign_angle_torsion(130,-10,67);
     assign_angle_torsion(135,-10,38);
     assign_angle_torsion(140,-10,23);
     assign_angle_torsion(145,-10,7);
     assign_angle_torsion(150,-10,2);
     assign_angle_torsion(155,-10,2);
     assign_angle_torsion(160,-10,0);
     assign_angle_torsion(165,-10,0);
     assign_angle_torsion(170,-10,0);
     assign_angle_torsion(175,-10,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_350() {
 
     assign_angle_torsion(0,-15,0);
     assign_angle_torsion(5,-15,0);
     assign_angle_torsion(10,-15,0);
     assign_angle_torsion(15,-15,0);
     assign_angle_torsion(20,-15,0);
     assign_angle_torsion(25,-15,0);
     assign_angle_torsion(30,-15,0);
     assign_angle_torsion(35,-15,0);
     assign_angle_torsion(40,-15,0);
     assign_angle_torsion(45,-15,0);
     assign_angle_torsion(50,-15,0);
     assign_angle_torsion(55,-15,0);
     assign_angle_torsion(60,-15,0);
     assign_angle_torsion(65,-15,0);
     assign_angle_torsion(70,-15,0);
     assign_angle_torsion(75,-15,2);
     assign_angle_torsion(80,-15,0);
     assign_angle_torsion(85,-15,38);
     assign_angle_torsion(90,-15,75);
     assign_angle_torsion(95,-15,130);
     assign_angle_torsion(100,-15,95);
     assign_angle_torsion(105,-15,122);
     assign_angle_torsion(110,-15,110);
     assign_angle_torsion(115,-15,116);
     assign_angle_torsion(120,-15,117);
     assign_angle_torsion(125,-15,92);
     assign_angle_torsion(130,-15,68);
     assign_angle_torsion(135,-15,63);
     assign_angle_torsion(140,-15,29);
     assign_angle_torsion(145,-15,7);
     assign_angle_torsion(150,-15,2);
     assign_angle_torsion(155,-15,0);
     assign_angle_torsion(160,-15,1);
     assign_angle_torsion(165,-15,0);
     assign_angle_torsion(170,-15,0);
     assign_angle_torsion(175,-15,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_345() {
 
     assign_angle_torsion(0,-20,0);
     assign_angle_torsion(5,-20,0);
     assign_angle_torsion(10,-20,0);
     assign_angle_torsion(15,-20,0);
     assign_angle_torsion(20,-20,0);
     assign_angle_torsion(25,-20,0);
     assign_angle_torsion(30,-20,0);
     assign_angle_torsion(35,-20,0);
     assign_angle_torsion(40,-20,0);
     assign_angle_torsion(45,-20,1);
     assign_angle_torsion(50,-20,0);
     assign_angle_torsion(55,-20,0);
     assign_angle_torsion(60,-20,0);
     assign_angle_torsion(65,-20,0);
     assign_angle_torsion(70,-20,0);
     assign_angle_torsion(75,-20,1);
     assign_angle_torsion(80,-20,3);
     assign_angle_torsion(85,-20,27);
     assign_angle_torsion(90,-20,51);
     assign_angle_torsion(95,-20,86);
     assign_angle_torsion(100,-20,86);
     assign_angle_torsion(105,-20,104);
     assign_angle_torsion(110,-20,113);
     assign_angle_torsion(115,-20,101);
     assign_angle_torsion(120,-20,96);
     assign_angle_torsion(125,-20,78);
     assign_angle_torsion(130,-20,58);
     assign_angle_torsion(135,-20,63);
     assign_angle_torsion(140,-20,37);
     assign_angle_torsion(145,-20,16);
     assign_angle_torsion(150,-20,1);
     assign_angle_torsion(155,-20,0);
     assign_angle_torsion(160,-20,1);
     assign_angle_torsion(165,-20,0);
     assign_angle_torsion(170,-20,0);
     assign_angle_torsion(175,-20,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_340() {
 
     assign_angle_torsion(0,-25,0);
     assign_angle_torsion(5,-25,0);
     assign_angle_torsion(10,-25,0);
     assign_angle_torsion(15,-25,0);
     assign_angle_torsion(20,-25,0);
     assign_angle_torsion(25,-25,0);
     assign_angle_torsion(30,-25,0);
     assign_angle_torsion(35,-25,0);
     assign_angle_torsion(40,-25,0);
     assign_angle_torsion(45,-25,0);
     assign_angle_torsion(50,-25,0);
     assign_angle_torsion(55,-25,0);
     assign_angle_torsion(60,-25,0);
     assign_angle_torsion(65,-25,0);
     assign_angle_torsion(70,-25,0);
     assign_angle_torsion(75,-25,0);
     assign_angle_torsion(80,-25,1);
     assign_angle_torsion(85,-25,22);
     assign_angle_torsion(90,-25,46);
     assign_angle_torsion(95,-25,46);
     assign_angle_torsion(100,-25,64);
     assign_angle_torsion(105,-25,72);
     assign_angle_torsion(110,-25,84);
     assign_angle_torsion(115,-25,52);
     assign_angle_torsion(120,-25,78);
     assign_angle_torsion(125,-25,67);
     assign_angle_torsion(130,-25,42);
     assign_angle_torsion(135,-25,77);
     assign_angle_torsion(140,-25,54);
     assign_angle_torsion(145,-25,21);
     assign_angle_torsion(150,-25,5);
     assign_angle_torsion(155,-25,0);
     assign_angle_torsion(160,-25,0);
     assign_angle_torsion(165,-25,0);
     assign_angle_torsion(170,-25,1);
     assign_angle_torsion(175,-25,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_335() {
 
     assign_angle_torsion(0,-30,0);
     assign_angle_torsion(5,-30,0);
     assign_angle_torsion(10,-30,0);
     assign_angle_torsion(15,-30,0);
     assign_angle_torsion(20,-30,0);
     assign_angle_torsion(25,-30,0);
     assign_angle_torsion(30,-30,0);
     assign_angle_torsion(35,-30,0);
     assign_angle_torsion(40,-30,0);
     assign_angle_torsion(45,-30,0);
     assign_angle_torsion(50,-30,0);
     assign_angle_torsion(55,-30,0);
     assign_angle_torsion(60,-30,0);
     assign_angle_torsion(65,-30,0);
     assign_angle_torsion(70,-30,0);
     assign_angle_torsion(75,-30,0);
     assign_angle_torsion(80,-30,0);
     assign_angle_torsion(85,-30,8);
     assign_angle_torsion(90,-30,51);
     assign_angle_torsion(95,-30,48);
     assign_angle_torsion(100,-30,51);
     assign_angle_torsion(105,-30,34);
     assign_angle_torsion(110,-30,64);
     assign_angle_torsion(115,-30,71);
     assign_angle_torsion(120,-30,53);
     assign_angle_torsion(125,-30,55);
     assign_angle_torsion(130,-30,47);
     assign_angle_torsion(135,-30,59);
     assign_angle_torsion(140,-30,60);
     assign_angle_torsion(145,-30,36);
     assign_angle_torsion(150,-30,4);
     assign_angle_torsion(155,-30,2);
     assign_angle_torsion(160,-30,0);
     assign_angle_torsion(165,-30,0);
     assign_angle_torsion(170,-30,0);
     assign_angle_torsion(175,-30,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_330() {
 
     assign_angle_torsion(0,-35,0);
     assign_angle_torsion(5,-35,0);
     assign_angle_torsion(10,-35,0);
     assign_angle_torsion(15,-35,0);
     assign_angle_torsion(20,-35,0);
     assign_angle_torsion(25,-35,0);
     assign_angle_torsion(30,-35,0);
     assign_angle_torsion(35,-35,0);
     assign_angle_torsion(40,-35,0);
     assign_angle_torsion(45,-35,0);
     assign_angle_torsion(50,-35,0);
     assign_angle_torsion(55,-35,0);
     assign_angle_torsion(60,-35,1);
     assign_angle_torsion(65,-35,0);
     assign_angle_torsion(70,-35,0);
     assign_angle_torsion(75,-35,0);
     assign_angle_torsion(80,-35,2);
     assign_angle_torsion(85,-35,16);
     assign_angle_torsion(90,-35,54);
     assign_angle_torsion(95,-35,54);
     assign_angle_torsion(100,-35,48);
     assign_angle_torsion(105,-35,39);
     assign_angle_torsion(110,-35,51);
     assign_angle_torsion(115,-35,65);
     assign_angle_torsion(120,-35,73);
     assign_angle_torsion(125,-35,59);
     assign_angle_torsion(130,-35,59);
     assign_angle_torsion(135,-35,60);
     assign_angle_torsion(140,-35,67);
     assign_angle_torsion(145,-35,25);
     assign_angle_torsion(150,-35,6);
     assign_angle_torsion(155,-35,0);
     assign_angle_torsion(160,-35,1);
     assign_angle_torsion(165,-35,0);
     assign_angle_torsion(170,-35,0);
     assign_angle_torsion(175,-35,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_325() {
 
     assign_angle_torsion(0,-40,0);
     assign_angle_torsion(5,-40,0);
     assign_angle_torsion(10,-40,0);
     assign_angle_torsion(15,-40,0);
     assign_angle_torsion(20,-40,0);
     assign_angle_torsion(25,-40,0);
     assign_angle_torsion(30,-40,0);
     assign_angle_torsion(35,-40,0);
     assign_angle_torsion(40,-40,0);
     assign_angle_torsion(45,-40,0);
     assign_angle_torsion(50,-40,0);
     assign_angle_torsion(55,-40,0);
     assign_angle_torsion(60,-40,0);
     assign_angle_torsion(65,-40,0);
     assign_angle_torsion(70,-40,0);
     assign_angle_torsion(75,-40,0);
     assign_angle_torsion(80,-40,1);
     assign_angle_torsion(85,-40,18);
     assign_angle_torsion(90,-40,67);
     assign_angle_torsion(95,-40,56);
     assign_angle_torsion(100,-40,52);
     assign_angle_torsion(105,-40,51);
     assign_angle_torsion(110,-40,43);
     assign_angle_torsion(115,-40,49);
     assign_angle_torsion(120,-40,48);
     assign_angle_torsion(125,-40,55);
     assign_angle_torsion(130,-40,57);
     assign_angle_torsion(135,-40,79);
     assign_angle_torsion(140,-40,74);
     assign_angle_torsion(145,-40,40);
     assign_angle_torsion(150,-40,9);
     assign_angle_torsion(155,-40,4);
     assign_angle_torsion(160,-40,0);
     assign_angle_torsion(165,-40,0);
     assign_angle_torsion(170,-40,0);
     assign_angle_torsion(175,-40,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_320() {
 
     assign_angle_torsion(0,-45,0);
     assign_angle_torsion(5,-45,0);
     assign_angle_torsion(10,-45,0);
     assign_angle_torsion(15,-45,0);
     assign_angle_torsion(20,-45,0);
     assign_angle_torsion(25,-45,0);
     assign_angle_torsion(30,-45,0);
     assign_angle_torsion(35,-45,0);
     assign_angle_torsion(40,-45,0);
     assign_angle_torsion(45,-45,0);
     assign_angle_torsion(50,-45,0);
     assign_angle_torsion(55,-45,0);
     assign_angle_torsion(60,-45,0);
     assign_angle_torsion(65,-45,0);
     assign_angle_torsion(70,-45,0);
     assign_angle_torsion(75,-45,1);
     assign_angle_torsion(80,-45,3);
     assign_angle_torsion(85,-45,38);
     assign_angle_torsion(90,-45,147);
     assign_angle_torsion(95,-45,80);
     assign_angle_torsion(100,-45,52);
     assign_angle_torsion(105,-45,36);
     assign_angle_torsion(110,-45,32);
     assign_angle_torsion(115,-45,38);
     assign_angle_torsion(120,-45,43);
     assign_angle_torsion(125,-45,48);
     assign_angle_torsion(130,-45,55);
     assign_angle_torsion(135,-45,67);
     assign_angle_torsion(140,-45,73);
     assign_angle_torsion(145,-45,40);
     assign_angle_torsion(150,-45,24);
     assign_angle_torsion(155,-45,3);
     assign_angle_torsion(160,-45,1);
     assign_angle_torsion(165,-45,0);
     assign_angle_torsion(170,-45,0);
     assign_angle_torsion(175,-45,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_315() {
 
     assign_angle_torsion(0,-50,0);
     assign_angle_torsion(5,-50,0);
     assign_angle_torsion(10,-50,0);
     assign_angle_torsion(15,-50,0);
     assign_angle_torsion(20,-50,0);
     assign_angle_torsion(25,-50,0);
     assign_angle_torsion(30,-50,0);
     assign_angle_torsion(35,-50,0);
     assign_angle_torsion(40,-50,0);
     assign_angle_torsion(45,-50,0);
     assign_angle_torsion(50,-50,0);
     assign_angle_torsion(55,-50,0);
     assign_angle_torsion(60,-50,0);
     assign_angle_torsion(65,-50,0);
     assign_angle_torsion(70,-50,0);
     assign_angle_torsion(75,-50,3);
     assign_angle_torsion(80,-50,3);
     assign_angle_torsion(85,-50,117);
     assign_angle_torsion(90,-50,222);
     assign_angle_torsion(95,-50,60);
     assign_angle_torsion(100,-50,37);
     assign_angle_torsion(105,-50,24);
     assign_angle_torsion(110,-50,28);
     assign_angle_torsion(115,-50,36);
     assign_angle_torsion(120,-50,35);
     assign_angle_torsion(125,-50,60);
     assign_angle_torsion(130,-50,112);
     assign_angle_torsion(135,-50,75);
     assign_angle_torsion(140,-50,92);
     assign_angle_torsion(145,-50,51);
     assign_angle_torsion(150,-50,26);
     assign_angle_torsion(155,-50,7);
     assign_angle_torsion(160,-50,0);
     assign_angle_torsion(165,-50,2);
     assign_angle_torsion(170,-50,0);
     assign_angle_torsion(175,-50,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_310() {
 
     assign_angle_torsion(0,-55,0);
     assign_angle_torsion(5,-55,0);
     assign_angle_torsion(10,-55,0);
     assign_angle_torsion(15,-55,0);
     assign_angle_torsion(20,-55,0);
     assign_angle_torsion(25,-55,0);
     assign_angle_torsion(30,-55,0);
     assign_angle_torsion(35,-55,0);
     assign_angle_torsion(40,-55,0);
     assign_angle_torsion(45,-55,0);
     assign_angle_torsion(50,-55,0);
     assign_angle_torsion(55,-55,1);
     assign_angle_torsion(60,-55,0);
     assign_angle_torsion(65,-55,0);
     assign_angle_torsion(70,-55,0);
     assign_angle_torsion(75,-55,0);
     assign_angle_torsion(80,-55,11);
     assign_angle_torsion(85,-55,136);
     assign_angle_torsion(90,-55,151);
     assign_angle_torsion(95,-55,58);
     assign_angle_torsion(100,-55,31);
     assign_angle_torsion(105,-55,27);
     assign_angle_torsion(110,-55,26);
     assign_angle_torsion(115,-55,39);
     assign_angle_torsion(120,-55,66);
     assign_angle_torsion(125,-55,71);
     assign_angle_torsion(130,-55,97);
     assign_angle_torsion(135,-55,108);
     assign_angle_torsion(140,-55,122);
     assign_angle_torsion(145,-55,67);
     assign_angle_torsion(150,-55,13);
     assign_angle_torsion(155,-55,4);
     assign_angle_torsion(160,-55,0);
     assign_angle_torsion(165,-55,0);
     assign_angle_torsion(170,-55,0);
     assign_angle_torsion(175,-55,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_305() {
 
     assign_angle_torsion(0,-60,2);
     assign_angle_torsion(5,-60,0);
     assign_angle_torsion(10,-60,0);
     assign_angle_torsion(15,-60,0);
     assign_angle_torsion(20,-60,0);
     assign_angle_torsion(25,-60,0);
     assign_angle_torsion(30,-60,0);
     assign_angle_torsion(35,-60,0);
     assign_angle_torsion(40,-60,0);
     assign_angle_torsion(45,-60,0);
     assign_angle_torsion(50,-60,0);
     assign_angle_torsion(55,-60,1);
     assign_angle_torsion(60,-60,0);
     assign_angle_torsion(65,-60,0);
     assign_angle_torsion(70,-60,2);
     assign_angle_torsion(75,-60,2);
     assign_angle_torsion(80,-60,24);
     assign_angle_torsion(85,-60,70);
     assign_angle_torsion(90,-60,81);
     assign_angle_torsion(95,-60,47);
     assign_angle_torsion(100,-60,42);
     assign_angle_torsion(105,-60,30);
     assign_angle_torsion(110,-60,23);
     assign_angle_torsion(115,-60,39);
     assign_angle_torsion(120,-60,86);
     assign_angle_torsion(125,-60,116);
     assign_angle_torsion(130,-60,116);
     assign_angle_torsion(135,-60,140);
     assign_angle_torsion(140,-60,134);
     assign_angle_torsion(145,-60,73);
     assign_angle_torsion(150,-60,14);
     assign_angle_torsion(155,-60,3);
     assign_angle_torsion(160,-60,0);
     assign_angle_torsion(165,-60,1);
     assign_angle_torsion(170,-60,0);
     assign_angle_torsion(175,-60,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_300() {
 
     assign_angle_torsion(0,-65,0);
     assign_angle_torsion(5,-65,0);
     assign_angle_torsion(10,-65,0);
     assign_angle_torsion(15,-65,0);
     assign_angle_torsion(20,-65,0);
     assign_angle_torsion(25,-65,0);
     assign_angle_torsion(30,-65,0);
     assign_angle_torsion(35,-65,0);
     assign_angle_torsion(40,-65,0);
     assign_angle_torsion(45,-65,0);
     assign_angle_torsion(50,-65,0);
     assign_angle_torsion(55,-65,2);
     assign_angle_torsion(60,-65,0);
     assign_angle_torsion(65,-65,0);
     assign_angle_torsion(70,-65,0);
     assign_angle_torsion(75,-65,0);
     assign_angle_torsion(80,-65,4);
     assign_angle_torsion(85,-65,30);
     assign_angle_torsion(90,-65,67);
     assign_angle_torsion(95,-65,48);
     assign_angle_torsion(100,-65,30);
     assign_angle_torsion(105,-65,25);
     assign_angle_torsion(110,-65,25);
     assign_angle_torsion(115,-65,58);
     assign_angle_torsion(120,-65,112);
     assign_angle_torsion(125,-65,122);
     assign_angle_torsion(130,-65,131);
     assign_angle_torsion(135,-65,187);
     assign_angle_torsion(140,-65,178);
     assign_angle_torsion(145,-65,84);
     assign_angle_torsion(150,-65,21);
     assign_angle_torsion(155,-65,2);
     assign_angle_torsion(160,-65,1);
     assign_angle_torsion(165,-65,0);
     assign_angle_torsion(170,-65,0);
     assign_angle_torsion(175,-65,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_295() {
 
     assign_angle_torsion(0,-70,0);
     assign_angle_torsion(5,-70,0);
     assign_angle_torsion(10,-70,0);
     assign_angle_torsion(15,-70,0);
     assign_angle_torsion(20,-70,0);
     assign_angle_torsion(25,-70,0);
     assign_angle_torsion(30,-70,0);
     assign_angle_torsion(35,-70,0);
     assign_angle_torsion(40,-70,0);
     assign_angle_torsion(45,-70,0);
     assign_angle_torsion(50,-70,0);
     assign_angle_torsion(55,-70,1);
     assign_angle_torsion(60,-70,1);
     assign_angle_torsion(65,-70,0);
     assign_angle_torsion(70,-70,1);
     assign_angle_torsion(75,-70,0);
     assign_angle_torsion(80,-70,6);
     assign_angle_torsion(85,-70,36);
     assign_angle_torsion(90,-70,64);
     assign_angle_torsion(95,-70,42);
     assign_angle_torsion(100,-70,24);
     assign_angle_torsion(105,-70,34);
     assign_angle_torsion(110,-70,26);
     assign_angle_torsion(115,-70,76);
     assign_angle_torsion(120,-70,124);
     assign_angle_torsion(125,-70,131);
     assign_angle_torsion(130,-70,181);
     assign_angle_torsion(135,-70,245);
     assign_angle_torsion(140,-70,159);
     assign_angle_torsion(145,-70,89);
     assign_angle_torsion(150,-70,15);
     assign_angle_torsion(155,-70,2);
     assign_angle_torsion(160,-70,0);
     assign_angle_torsion(165,-70,0);
     assign_angle_torsion(170,-70,0);
     assign_angle_torsion(175,-70,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_290() {
 
     assign_angle_torsion(0,-75,0);
     assign_angle_torsion(5,-75,0);
     assign_angle_torsion(10,-75,0);
     assign_angle_torsion(15,-75,0);
     assign_angle_torsion(20,-75,0);
     assign_angle_torsion(25,-75,0);
     assign_angle_torsion(30,-75,0);
     assign_angle_torsion(35,-75,0);
     assign_angle_torsion(40,-75,0);
     assign_angle_torsion(45,-75,0);
     assign_angle_torsion(50,-75,0);
     assign_angle_torsion(55,-75,1);
     assign_angle_torsion(60,-75,0);
     assign_angle_torsion(65,-75,0);
     assign_angle_torsion(70,-75,0);
     assign_angle_torsion(75,-75,1);
     assign_angle_torsion(80,-75,7);
     assign_angle_torsion(85,-75,45);
     assign_angle_torsion(90,-75,54);
     assign_angle_torsion(95,-75,40);
     assign_angle_torsion(100,-75,37);
     assign_angle_torsion(105,-75,34);
     assign_angle_torsion(110,-75,46);
     assign_angle_torsion(115,-75,147);
     assign_angle_torsion(120,-75,219);
     assign_angle_torsion(125,-75,255);
     assign_angle_torsion(130,-75,260);
     assign_angle_torsion(135,-75,262);
     assign_angle_torsion(140,-75,186);
     assign_angle_torsion(145,-75,76);
     assign_angle_torsion(150,-75,12);
     assign_angle_torsion(155,-75,0);
     assign_angle_torsion(160,-75,2);
     assign_angle_torsion(165,-75,1);
     assign_angle_torsion(170,-75,0);
     assign_angle_torsion(175,-75,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_285() {
 
     assign_angle_torsion(0,-80,0);
     assign_angle_torsion(5,-80,0);
     assign_angle_torsion(10,-80,0);
     assign_angle_torsion(15,-80,0);
     assign_angle_torsion(20,-80,0);
     assign_angle_torsion(25,-80,0);
     assign_angle_torsion(30,-80,0);
     assign_angle_torsion(35,-80,0);
     assign_angle_torsion(40,-80,0);
     assign_angle_torsion(45,-80,0);
     assign_angle_torsion(50,-80,0);
     assign_angle_torsion(55,-80,0);
     assign_angle_torsion(60,-80,1);
     assign_angle_torsion(65,-80,0);
     assign_angle_torsion(70,-80,0);
     assign_angle_torsion(75,-80,0);
     assign_angle_torsion(80,-80,5);
     assign_angle_torsion(85,-80,39);
     assign_angle_torsion(90,-80,53);
     assign_angle_torsion(95,-80,55);
     assign_angle_torsion(100,-80,52);
     assign_angle_torsion(105,-80,35);
     assign_angle_torsion(110,-80,71);
     assign_angle_torsion(115,-80,213);
     assign_angle_torsion(120,-80,293);
     assign_angle_torsion(125,-80,310);
     assign_angle_torsion(130,-80,283);
     assign_angle_torsion(135,-80,276);
     assign_angle_torsion(140,-80,211);
     assign_angle_torsion(145,-80,98);
     assign_angle_torsion(150,-80,27);
     assign_angle_torsion(155,-80,0);
     assign_angle_torsion(160,-80,0);
     assign_angle_torsion(165,-80,0);
     assign_angle_torsion(170,-80,0);
     assign_angle_torsion(175,-80,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_280() {
 
     assign_angle_torsion(0,-85,0);
     assign_angle_torsion(5,-85,0);
     assign_angle_torsion(10,-85,0);
     assign_angle_torsion(15,-85,0);
     assign_angle_torsion(20,-85,0);
     assign_angle_torsion(25,-85,0);
     assign_angle_torsion(30,-85,0);
     assign_angle_torsion(35,-85,0);
     assign_angle_torsion(40,-85,0);
     assign_angle_torsion(45,-85,0);
     assign_angle_torsion(50,-85,0);
     assign_angle_torsion(55,-85,0);
     assign_angle_torsion(60,-85,1);
     assign_angle_torsion(65,-85,0);
     assign_angle_torsion(70,-85,0);
     assign_angle_torsion(75,-85,3);
     assign_angle_torsion(80,-85,6);
     assign_angle_torsion(85,-85,60);
     assign_angle_torsion(90,-85,72);
     assign_angle_torsion(95,-85,104);
     assign_angle_torsion(100,-85,33);
     assign_angle_torsion(105,-85,42);
     assign_angle_torsion(110,-85,129);
     assign_angle_torsion(115,-85,280);
     assign_angle_torsion(120,-85,342);
     assign_angle_torsion(125,-85,337);
     assign_angle_torsion(130,-85,341);
     assign_angle_torsion(135,-85,292);
     assign_angle_torsion(140,-85,214);
     assign_angle_torsion(145,-85,133);
     assign_angle_torsion(150,-85,26);
     assign_angle_torsion(155,-85,2);
     assign_angle_torsion(160,-85,0);
     assign_angle_torsion(165,-85,0);
     assign_angle_torsion(170,-85,1);
     assign_angle_torsion(175,-85,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_275() {
 
     assign_angle_torsion(0,-90,0);
     assign_angle_torsion(5,-90,0);
     assign_angle_torsion(10,-90,0);
     assign_angle_torsion(15,-90,0);
     assign_angle_torsion(20,-90,0);
     assign_angle_torsion(25,-90,0);
     assign_angle_torsion(30,-90,0);
     assign_angle_torsion(35,-90,0);
     assign_angle_torsion(40,-90,0);
     assign_angle_torsion(45,-90,0);
     assign_angle_torsion(50,-90,0);
     assign_angle_torsion(55,-90,0);
     assign_angle_torsion(60,-90,0);
     assign_angle_torsion(65,-90,0);
     assign_angle_torsion(70,-90,0);
     assign_angle_torsion(75,-90,0);
     assign_angle_torsion(80,-90,4);
     assign_angle_torsion(85,-90,47);
     assign_angle_torsion(90,-90,141);
     assign_angle_torsion(95,-90,100);
     assign_angle_torsion(100,-90,50);
     assign_angle_torsion(105,-90,92);
     assign_angle_torsion(110,-90,147);
     assign_angle_torsion(115,-90,277);
     assign_angle_torsion(120,-90,373);
     assign_angle_torsion(125,-90,414);
     assign_angle_torsion(130,-90,373);
     assign_angle_torsion(135,-90,352);
     assign_angle_torsion(140,-90,303);
     assign_angle_torsion(145,-90,157);
     assign_angle_torsion(150,-90,24);
     assign_angle_torsion(155,-90,3);
     assign_angle_torsion(160,-90,0);
     assign_angle_torsion(165,-90,0);
     assign_angle_torsion(170,-90,2);
     assign_angle_torsion(175,-90,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_270() {
 
     assign_angle_torsion(0,-95,0);
     assign_angle_torsion(5,-95,0);
     assign_angle_torsion(10,-95,0);
     assign_angle_torsion(15,-95,0);
     assign_angle_torsion(20,-95,0);
     assign_angle_torsion(25,-95,0);
     assign_angle_torsion(30,-95,0);
     assign_angle_torsion(35,-95,0);
     assign_angle_torsion(40,-95,0);
     assign_angle_torsion(45,-95,0);
     assign_angle_torsion(50,-95,0);
     assign_angle_torsion(55,-95,0);
     assign_angle_torsion(60,-95,1);
     assign_angle_torsion(65,-95,0);
     assign_angle_torsion(70,-95,0);
     assign_angle_torsion(75,-95,1);
     assign_angle_torsion(80,-95,2);
     assign_angle_torsion(85,-95,59);
     assign_angle_torsion(90,-95,249);
     assign_angle_torsion(95,-95,130);
     assign_angle_torsion(100,-95,99);
     assign_angle_torsion(105,-95,67);
     assign_angle_torsion(110,-95,224);
     assign_angle_torsion(115,-95,404);
     assign_angle_torsion(120,-95,525);
     assign_angle_torsion(125,-95,463);
     assign_angle_torsion(130,-95,467);
     assign_angle_torsion(135,-95,372);
     assign_angle_torsion(140,-95,307);
     assign_angle_torsion(145,-95,141);
     assign_angle_torsion(150,-95,54);
     assign_angle_torsion(155,-95,3);
     assign_angle_torsion(160,-95,2);
     assign_angle_torsion(165,-95,0);
     assign_angle_torsion(170,-95,0);
     assign_angle_torsion(175,-95,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_265() {
 
     assign_angle_torsion(0,-100,0);
     assign_angle_torsion(5,-100,0);
     assign_angle_torsion(10,-100,0);
     assign_angle_torsion(15,-100,0);
     assign_angle_torsion(20,-100,0);
     assign_angle_torsion(25,-100,0);
     assign_angle_torsion(30,-100,0);
     assign_angle_torsion(35,-100,1);
     assign_angle_torsion(40,-100,0);
     assign_angle_torsion(45,-100,0);
     assign_angle_torsion(50,-100,0);
     assign_angle_torsion(55,-100,0);
     assign_angle_torsion(60,-100,0);
     assign_angle_torsion(65,-100,0);
     assign_angle_torsion(70,-100,0);
     assign_angle_torsion(75,-100,2);
     assign_angle_torsion(80,-100,8);
     assign_angle_torsion(85,-100,120);
     assign_angle_torsion(90,-100,429);
     assign_angle_torsion(95,-100,175);
     assign_angle_torsion(100,-100,76);
     assign_angle_torsion(105,-100,132);
     assign_angle_torsion(110,-100,322);
     assign_angle_torsion(115,-100,516);
     assign_angle_torsion(120,-100,628);
     assign_angle_torsion(125,-100,557);
     assign_angle_torsion(130,-100,439);
     assign_angle_torsion(135,-100,472);
     assign_angle_torsion(140,-100,396);
     assign_angle_torsion(145,-100,132);
     assign_angle_torsion(150,-100,61);
     assign_angle_torsion(155,-100,5);
     assign_angle_torsion(160,-100,1);
     assign_angle_torsion(165,-100,0);
     assign_angle_torsion(170,-100,0);
     assign_angle_torsion(175,-100,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_260() {
 
     assign_angle_torsion(0,-105,0);
     assign_angle_torsion(5,-105,0);
     assign_angle_torsion(10,-105,0);
     assign_angle_torsion(15,-105,0);
     assign_angle_torsion(20,-105,0);
     assign_angle_torsion(25,-105,0);
     assign_angle_torsion(30,-105,0);
     assign_angle_torsion(35,-105,0);
     assign_angle_torsion(40,-105,0);
     assign_angle_torsion(45,-105,0);
     assign_angle_torsion(50,-105,1);
     assign_angle_torsion(55,-105,0);
     assign_angle_torsion(60,-105,0);
     assign_angle_torsion(65,-105,0);
     assign_angle_torsion(70,-105,0);
     assign_angle_torsion(75,-105,0);
     assign_angle_torsion(80,-105,5);
     assign_angle_torsion(85,-105,127);
     assign_angle_torsion(90,-105,504);
     assign_angle_torsion(95,-105,142);
     assign_angle_torsion(100,-105,122);
     assign_angle_torsion(105,-105,183);
     assign_angle_torsion(110,-105,382);
     assign_angle_torsion(115,-105,591);
     assign_angle_torsion(120,-105,758);
     assign_angle_torsion(125,-105,609);
     assign_angle_torsion(130,-105,566);
     assign_angle_torsion(135,-105,469);
     assign_angle_torsion(140,-105,291);
     assign_angle_torsion(145,-105,169);
     assign_angle_torsion(150,-105,55);
     assign_angle_torsion(155,-105,3);
     assign_angle_torsion(160,-105,0);
     assign_angle_torsion(165,-105,0);
     assign_angle_torsion(170,-105,0);
     assign_angle_torsion(175,-105,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_255() {
 
     assign_angle_torsion(0,-110,0);
     assign_angle_torsion(5,-110,0);
     assign_angle_torsion(10,-110,0);
     assign_angle_torsion(15,-110,0);
     assign_angle_torsion(20,-110,0);
     assign_angle_torsion(25,-110,0);
     assign_angle_torsion(30,-110,0);
     assign_angle_torsion(35,-110,0);
     assign_angle_torsion(40,-110,0);
     assign_angle_torsion(45,-110,0);
     assign_angle_torsion(50,-110,0);
     assign_angle_torsion(55,-110,0);
     assign_angle_torsion(60,-110,0);
     assign_angle_torsion(65,-110,0);
     assign_angle_torsion(70,-110,0);
     assign_angle_torsion(75,-110,0);
     assign_angle_torsion(80,-110,13);
     assign_angle_torsion(85,-110,148);
     assign_angle_torsion(90,-110,349);
     assign_angle_torsion(95,-110,209);
     assign_angle_torsion(100,-110,117);
     assign_angle_torsion(105,-110,235);
     assign_angle_torsion(110,-110,507);
     assign_angle_torsion(115,-110,704);
     assign_angle_torsion(120,-110,793);
     assign_angle_torsion(125,-110,609);
     assign_angle_torsion(130,-110,543);
     assign_angle_torsion(135,-110,472);
     assign_angle_torsion(140,-110,380);
     assign_angle_torsion(145,-110,170);
     assign_angle_torsion(150,-110,41);
     assign_angle_torsion(155,-110,4);
     assign_angle_torsion(160,-110,1);
     assign_angle_torsion(165,-110,0);
     assign_angle_torsion(170,-110,0);
     assign_angle_torsion(175,-110,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_250() {
 
     assign_angle_torsion(0,-115,0);
     assign_angle_torsion(5,-115,0);
     assign_angle_torsion(10,-115,0);
     assign_angle_torsion(15,-115,0);
     assign_angle_torsion(20,-115,0);
     assign_angle_torsion(25,-115,1);
     assign_angle_torsion(30,-115,0);
     assign_angle_torsion(35,-115,0);
     assign_angle_torsion(40,-115,0);
     assign_angle_torsion(45,-115,0);
     assign_angle_torsion(50,-115,0);
     assign_angle_torsion(55,-115,0);
     assign_angle_torsion(60,-115,0);
     assign_angle_torsion(65,-115,0);
     assign_angle_torsion(70,-115,0);
     assign_angle_torsion(75,-115,1);
     assign_angle_torsion(80,-115,7);
     assign_angle_torsion(85,-115,113);
     assign_angle_torsion(90,-115,342);
     assign_angle_torsion(95,-115,249);
     assign_angle_torsion(100,-115,135);
     assign_angle_torsion(105,-115,298);
     assign_angle_torsion(110,-115,619);
     assign_angle_torsion(115,-115,862);
     assign_angle_torsion(120,-115,709);
     assign_angle_torsion(125,-115,562);
     assign_angle_torsion(130,-115,549);
     assign_angle_torsion(135,-115,504);
     assign_angle_torsion(140,-115,360);
     assign_angle_torsion(145,-115,162);
     assign_angle_torsion(150,-115,42);
     assign_angle_torsion(155,-115,3);
     assign_angle_torsion(160,-115,0);
     assign_angle_torsion(165,-115,0);
     assign_angle_torsion(170,-115,0);
     assign_angle_torsion(175,-115,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_245() {
 
     assign_angle_torsion(0,-120,0);
     assign_angle_torsion(5,-120,0);
     assign_angle_torsion(10,-120,0);
     assign_angle_torsion(15,-120,0);
     assign_angle_torsion(20,-120,0);
     assign_angle_torsion(25,-120,0);
     assign_angle_torsion(30,-120,0);
     assign_angle_torsion(35,-120,0);
     assign_angle_torsion(40,-120,1);
     assign_angle_torsion(45,-120,0);
     assign_angle_torsion(50,-120,1);
     assign_angle_torsion(55,-120,0);
     assign_angle_torsion(60,-120,0);
     assign_angle_torsion(65,-120,0);
     assign_angle_torsion(70,-120,0);
     assign_angle_torsion(75,-120,1);
     assign_angle_torsion(80,-120,1);
     assign_angle_torsion(85,-120,98);
     assign_angle_torsion(90,-120,305);
     assign_angle_torsion(95,-120,263);
     assign_angle_torsion(100,-120,149);
     assign_angle_torsion(105,-120,399);
     assign_angle_torsion(110,-120,699);
     assign_angle_torsion(115,-120,807);
     assign_angle_torsion(120,-120,768);
     assign_angle_torsion(125,-120,677);
     assign_angle_torsion(130,-120,575);
     assign_angle_torsion(135,-120,519);
     assign_angle_torsion(140,-120,366);
     assign_angle_torsion(145,-120,182);
     assign_angle_torsion(150,-120,50);
     assign_angle_torsion(155,-120,3);
     assign_angle_torsion(160,-120,1);
     assign_angle_torsion(165,-120,0);
     assign_angle_torsion(170,-120,0);
     assign_angle_torsion(175,-120,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_240() {
 
     assign_angle_torsion(0,-125,0);
     assign_angle_torsion(5,-125,0);
     assign_angle_torsion(10,-125,0);
     assign_angle_torsion(15,-125,0);
     assign_angle_torsion(20,-125,0);
     assign_angle_torsion(25,-125,0);
     assign_angle_torsion(30,-125,0);
     assign_angle_torsion(35,-125,0);
     assign_angle_torsion(40,-125,0);
     assign_angle_torsion(45,-125,0);
     assign_angle_torsion(50,-125,0);
     assign_angle_torsion(55,-125,0);
     assign_angle_torsion(60,-125,0);
     assign_angle_torsion(65,-125,0);
     assign_angle_torsion(70,-125,7);
     assign_angle_torsion(75,-125,1);
     assign_angle_torsion(80,-125,11);
     assign_angle_torsion(85,-125,94);
     assign_angle_torsion(90,-125,328);
     assign_angle_torsion(95,-125,295);
     assign_angle_torsion(100,-125,209);
     assign_angle_torsion(105,-125,431);
     assign_angle_torsion(110,-125,718);
     assign_angle_torsion(115,-125,815);
     assign_angle_torsion(120,-125,796);
     assign_angle_torsion(125,-125,662);
     assign_angle_torsion(130,-125,618);
     assign_angle_torsion(135,-125,511);
     assign_angle_torsion(140,-125,364);
     assign_angle_torsion(145,-125,130);
     assign_angle_torsion(150,-125,34);
     assign_angle_torsion(155,-125,1);
     assign_angle_torsion(160,-125,0);
     assign_angle_torsion(165,-125,0);
     assign_angle_torsion(170,-125,0);
     assign_angle_torsion(175,-125,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_235() {
 
     assign_angle_torsion(0,-130,0);
     assign_angle_torsion(5,-130,0);
     assign_angle_torsion(10,-130,0);
     assign_angle_torsion(15,-130,0);
     assign_angle_torsion(20,-130,0);
     assign_angle_torsion(25,-130,0);
     assign_angle_torsion(30,-130,0);
     assign_angle_torsion(35,-130,0);
     assign_angle_torsion(40,-130,1);
     assign_angle_torsion(45,-130,0);
     assign_angle_torsion(50,-130,0);
     assign_angle_torsion(55,-130,0);
     assign_angle_torsion(60,-130,0);
     assign_angle_torsion(65,-130,0);
     assign_angle_torsion(70,-130,0);
     assign_angle_torsion(75,-130,1);
     assign_angle_torsion(80,-130,15);
     assign_angle_torsion(85,-130,63);
     assign_angle_torsion(90,-130,224);
     assign_angle_torsion(95,-130,210);
     assign_angle_torsion(100,-130,180);
     assign_angle_torsion(105,-130,348);
     assign_angle_torsion(110,-130,690);
     assign_angle_torsion(115,-130,886);
     assign_angle_torsion(120,-130,766);
     assign_angle_torsion(125,-130,630);
     assign_angle_torsion(130,-130,578);
     assign_angle_torsion(135,-130,475);
     assign_angle_torsion(140,-130,350);
     assign_angle_torsion(145,-130,146);
     assign_angle_torsion(150,-130,32);
     assign_angle_torsion(155,-130,1);
     assign_angle_torsion(160,-130,2);
     assign_angle_torsion(165,-130,0);
     assign_angle_torsion(170,-130,0);
     assign_angle_torsion(175,-130,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_230() {
 
     assign_angle_torsion(0,-135,0);
     assign_angle_torsion(5,-135,0);
     assign_angle_torsion(10,-135,0);
     assign_angle_torsion(15,-135,0);
     assign_angle_torsion(20,-135,0);
     assign_angle_torsion(25,-135,0);
     assign_angle_torsion(30,-135,0);
     assign_angle_torsion(35,-135,0);
     assign_angle_torsion(40,-135,0);
     assign_angle_torsion(45,-135,0);
     assign_angle_torsion(50,-135,0);
     assign_angle_torsion(55,-135,0);
     assign_angle_torsion(60,-135,0);
     assign_angle_torsion(65,-135,0);
     assign_angle_torsion(70,-135,0);
     assign_angle_torsion(75,-135,0);
     assign_angle_torsion(80,-135,8);
     assign_angle_torsion(85,-135,95);
     assign_angle_torsion(90,-135,155);
     assign_angle_torsion(95,-135,152);
     assign_angle_torsion(100,-135,182);
     assign_angle_torsion(105,-135,440);
     assign_angle_torsion(110,-135,786);
     assign_angle_torsion(115,-135,941);
     assign_angle_torsion(120,-135,782);
     assign_angle_torsion(125,-135,667);
     assign_angle_torsion(130,-135,664);
     assign_angle_torsion(135,-135,466);
     assign_angle_torsion(140,-135,352);
     assign_angle_torsion(145,-135,170);
     assign_angle_torsion(150,-135,34);
     assign_angle_torsion(155,-135,5);
     assign_angle_torsion(160,-135,2);
     assign_angle_torsion(165,-135,0);
     assign_angle_torsion(170,-135,1);
     assign_angle_torsion(175,-135,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_225() {
 
     assign_angle_torsion(0,-140,0);
     assign_angle_torsion(5,-140,0);
     assign_angle_torsion(10,-140,0);
     assign_angle_torsion(15,-140,0);
     assign_angle_torsion(20,-140,0);
     assign_angle_torsion(25,-140,0);
     assign_angle_torsion(30,-140,0);
     assign_angle_torsion(35,-140,0);
     assign_angle_torsion(40,-140,0);
     assign_angle_torsion(45,-140,0);
     assign_angle_torsion(50,-140,0);
     assign_angle_torsion(55,-140,0);
     assign_angle_torsion(60,-140,0);
     assign_angle_torsion(65,-140,0);
     assign_angle_torsion(70,-140,0);
     assign_angle_torsion(75,-140,0);
     assign_angle_torsion(80,-140,9);
     assign_angle_torsion(85,-140,74);
     assign_angle_torsion(90,-140,114);
     assign_angle_torsion(95,-140,135);
     assign_angle_torsion(100,-140,233);
     assign_angle_torsion(105,-140,500);
     assign_angle_torsion(110,-140,838);
     assign_angle_torsion(115,-140,986);
     assign_angle_torsion(120,-140,884);
     assign_angle_torsion(125,-140,734);
     assign_angle_torsion(130,-140,552);
     assign_angle_torsion(135,-140,514);
     assign_angle_torsion(140,-140,363);
     assign_angle_torsion(145,-140,142);
     assign_angle_torsion(150,-140,32);
     assign_angle_torsion(155,-140,2);
     assign_angle_torsion(160,-140,1);
     assign_angle_torsion(165,-140,0);
     assign_angle_torsion(170,-140,0);
     assign_angle_torsion(175,-140,1);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_220() {
 
     assign_angle_torsion(0,-145,0);
     assign_angle_torsion(5,-145,0);
     assign_angle_torsion(10,-145,0);
     assign_angle_torsion(15,-145,0);
     assign_angle_torsion(20,-145,0);
     assign_angle_torsion(25,-145,0);
     assign_angle_torsion(30,-145,0);
     assign_angle_torsion(35,-145,0);
     assign_angle_torsion(40,-145,0);
     assign_angle_torsion(45,-145,0);
     assign_angle_torsion(50,-145,0);
     assign_angle_torsion(55,-145,0);
     assign_angle_torsion(60,-145,2);
     assign_angle_torsion(65,-145,0);
     assign_angle_torsion(70,-145,0);
     assign_angle_torsion(75,-145,4);
     assign_angle_torsion(80,-145,11);
     assign_angle_torsion(85,-145,67);
     assign_angle_torsion(90,-145,109);
     assign_angle_torsion(95,-145,152);
     assign_angle_torsion(100,-145,272);
     assign_angle_torsion(105,-145,562);
     assign_angle_torsion(110,-145,872);
     assign_angle_torsion(115,-145,1037);
     assign_angle_torsion(120,-145,891);
     assign_angle_torsion(125,-145,738);
     assign_angle_torsion(130,-145,677);
     assign_angle_torsion(135,-145,554);
     assign_angle_torsion(140,-145,333);
     assign_angle_torsion(145,-145,148);
     assign_angle_torsion(150,-145,26);
     assign_angle_torsion(155,-145,4);
     assign_angle_torsion(160,-145,0);
     assign_angle_torsion(165,-145,1);
     assign_angle_torsion(170,-145,0);
     assign_angle_torsion(175,-145,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_215() {
 
     assign_angle_torsion(0,-150,0);
     assign_angle_torsion(5,-150,0);
     assign_angle_torsion(10,-150,0);
     assign_angle_torsion(15,-150,0);
     assign_angle_torsion(20,-150,0);
     assign_angle_torsion(25,-150,0);
     assign_angle_torsion(30,-150,0);
     assign_angle_torsion(35,-150,0);
     assign_angle_torsion(40,-150,0);
     assign_angle_torsion(45,-150,0);
     assign_angle_torsion(50,-150,0);
     assign_angle_torsion(55,-150,0);
     assign_angle_torsion(60,-150,0);
     assign_angle_torsion(65,-150,0);
     assign_angle_torsion(70,-150,0);
     assign_angle_torsion(75,-150,6);
     assign_angle_torsion(80,-150,3);
     assign_angle_torsion(85,-150,57);
     assign_angle_torsion(90,-150,93);
     assign_angle_torsion(95,-150,130);
     assign_angle_torsion(100,-150,291);
     assign_angle_torsion(105,-150,617);
     assign_angle_torsion(110,-150,933);
     assign_angle_torsion(115,-150,1211);
     assign_angle_torsion(120,-150,1005);
     assign_angle_torsion(125,-150,740);
     assign_angle_torsion(130,-150,628);
     assign_angle_torsion(135,-150,532);
     assign_angle_torsion(140,-150,379);
     assign_angle_torsion(145,-150,149);
     assign_angle_torsion(150,-150,24);
     assign_angle_torsion(155,-150,2);
     assign_angle_torsion(160,-150,0);
     assign_angle_torsion(165,-150,0);
     assign_angle_torsion(170,-150,3);
     assign_angle_torsion(175,-150,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_210() {
 
     assign_angle_torsion(0,-155,0);
     assign_angle_torsion(5,-155,0);
     assign_angle_torsion(10,-155,0);
     assign_angle_torsion(15,-155,0);
     assign_angle_torsion(20,-155,0);
     assign_angle_torsion(25,-155,0);
     assign_angle_torsion(30,-155,0);
     assign_angle_torsion(35,-155,0);
     assign_angle_torsion(40,-155,0);
     assign_angle_torsion(45,-155,0);
     assign_angle_torsion(50,-155,0);
     assign_angle_torsion(55,-155,0);
     assign_angle_torsion(60,-155,0);
     assign_angle_torsion(65,-155,0);
     assign_angle_torsion(70,-155,0);
     assign_angle_torsion(75,-155,1);
     assign_angle_torsion(80,-155,13);
     assign_angle_torsion(85,-155,45);
     assign_angle_torsion(90,-155,93);
     assign_angle_torsion(95,-155,156);
     assign_angle_torsion(100,-155,311);
     assign_angle_torsion(105,-155,648);
     assign_angle_torsion(110,-155,1037);
     assign_angle_torsion(115,-155,1326);
     assign_angle_torsion(120,-155,1131);
     assign_angle_torsion(125,-155,972);
     assign_angle_torsion(130,-155,670);
     assign_angle_torsion(135,-155,474);
     assign_angle_torsion(140,-155,287);
     assign_angle_torsion(145,-155,96);
     assign_angle_torsion(150,-155,14);
     assign_angle_torsion(155,-155,2);
     assign_angle_torsion(160,-155,1);
     assign_angle_torsion(165,-155,0);
     assign_angle_torsion(170,-155,2);
     assign_angle_torsion(175,-155,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_205() {
 
     assign_angle_torsion(0,-160,0);
     assign_angle_torsion(5,-160,0);
     assign_angle_torsion(10,-160,0);
     assign_angle_torsion(15,-160,0);
     assign_angle_torsion(20,-160,0);
     assign_angle_torsion(25,-160,0);
     assign_angle_torsion(30,-160,0);
     assign_angle_torsion(35,-160,0);
     assign_angle_torsion(40,-160,0);
     assign_angle_torsion(45,-160,0);
     assign_angle_torsion(50,-160,0);
     assign_angle_torsion(55,-160,0);
     assign_angle_torsion(60,-160,0);
     assign_angle_torsion(65,-160,0);
     assign_angle_torsion(70,-160,0);
     assign_angle_torsion(75,-160,1);
     assign_angle_torsion(80,-160,6);
     assign_angle_torsion(85,-160,49);
     assign_angle_torsion(90,-160,100);
     assign_angle_torsion(95,-160,187);
     assign_angle_torsion(100,-160,420);
     assign_angle_torsion(105,-160,726);
     assign_angle_torsion(110,-160,1329);
     assign_angle_torsion(115,-160,1530);
     assign_angle_torsion(120,-160,1196);
     assign_angle_torsion(125,-160,1025);
     assign_angle_torsion(130,-160,683);
     assign_angle_torsion(135,-160,491);
     assign_angle_torsion(140,-160,246);
     assign_angle_torsion(145,-160,71);
     assign_angle_torsion(150,-160,15);
     assign_angle_torsion(155,-160,4);
     assign_angle_torsion(160,-160,1);
     assign_angle_torsion(165,-160,0);
     assign_angle_torsion(170,-160,1);
     assign_angle_torsion(175,-160,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_200() {
 
     assign_angle_torsion(0,-165,0);
     assign_angle_torsion(5,-165,0);
     assign_angle_torsion(10,-165,1);
     assign_angle_torsion(15,-165,0);
     assign_angle_torsion(20,-165,0);
     assign_angle_torsion(25,-165,0);
     assign_angle_torsion(30,-165,0);
     assign_angle_torsion(35,-165,0);
     assign_angle_torsion(40,-165,0);
     assign_angle_torsion(45,-165,0);
     assign_angle_torsion(50,-165,0);
     assign_angle_torsion(55,-165,0);
     assign_angle_torsion(60,-165,0);
     assign_angle_torsion(65,-165,0);
     assign_angle_torsion(70,-165,0);
     assign_angle_torsion(75,-165,2);
     assign_angle_torsion(80,-165,15);
     assign_angle_torsion(85,-165,58);
     assign_angle_torsion(90,-165,131);
     assign_angle_torsion(95,-165,220);
     assign_angle_torsion(100,-165,466);
     assign_angle_torsion(105,-165,704);
     assign_angle_torsion(110,-165,1066);
     assign_angle_torsion(115,-165,1384);
     assign_angle_torsion(120,-165,1216);
     assign_angle_torsion(125,-165,991);
     assign_angle_torsion(130,-165,691);
     assign_angle_torsion(135,-165,439);
     assign_angle_torsion(140,-165,261);
     assign_angle_torsion(145,-165,73);
     assign_angle_torsion(150,-165,10);
     assign_angle_torsion(155,-165,1);
     assign_angle_torsion(160,-165,0);
     assign_angle_torsion(165,-165,0);
     assign_angle_torsion(170,-165,1);
     assign_angle_torsion(175,-165,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_195() {
 
     assign_angle_torsion(0,-170,0);
     assign_angle_torsion(5,-170,0);
     assign_angle_torsion(10,-170,0);
     assign_angle_torsion(15,-170,0);
     assign_angle_torsion(20,-170,0);
     assign_angle_torsion(25,-170,0);
     assign_angle_torsion(30,-170,0);
     assign_angle_torsion(35,-170,0);
     assign_angle_torsion(40,-170,0);
     assign_angle_torsion(45,-170,0);
     assign_angle_torsion(50,-170,0);
     assign_angle_torsion(55,-170,0);
     assign_angle_torsion(60,-170,1);
     assign_angle_torsion(65,-170,2);
     assign_angle_torsion(70,-170,0);
     assign_angle_torsion(75,-170,2);
     assign_angle_torsion(80,-170,8);
     assign_angle_torsion(85,-170,40);
     assign_angle_torsion(90,-170,157);
     assign_angle_torsion(95,-170,240);
     assign_angle_torsion(100,-170,470);
     assign_angle_torsion(105,-170,604);
     assign_angle_torsion(110,-170,1029);
     assign_angle_torsion(115,-170,1265);
     assign_angle_torsion(120,-170,1113);
     assign_angle_torsion(125,-170,886);
     assign_angle_torsion(130,-170,647);
     assign_angle_torsion(135,-170,475);
     assign_angle_torsion(140,-170,287);
     assign_angle_torsion(145,-170,54);
     assign_angle_torsion(150,-170,5);
     assign_angle_torsion(155,-170,4);
     assign_angle_torsion(160,-170,3);
     assign_angle_torsion(165,-170,1);
     assign_angle_torsion(170,-170,1);
     assign_angle_torsion(175,-170,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_190() {
 
     assign_angle_torsion(0,-175,0);
     assign_angle_torsion(5,-175,0);
     assign_angle_torsion(10,-175,0);
     assign_angle_torsion(15,-175,0);
     assign_angle_torsion(20,-175,0);
     assign_angle_torsion(25,-175,0);
     assign_angle_torsion(30,-175,0);
     assign_angle_torsion(35,-175,0);
     assign_angle_torsion(40,-175,0);
     assign_angle_torsion(45,-175,0);
     assign_angle_torsion(50,-175,0);
     assign_angle_torsion(55,-175,0);
     assign_angle_torsion(60,-175,0);
     assign_angle_torsion(65,-175,0);
     assign_angle_torsion(70,-175,4);
     assign_angle_torsion(75,-175,2);
     assign_angle_torsion(80,-175,12);
     assign_angle_torsion(85,-175,89);
     assign_angle_torsion(90,-175,185);
     assign_angle_torsion(95,-175,227);
     assign_angle_torsion(100,-175,341);
     assign_angle_torsion(105,-175,631);
     assign_angle_torsion(110,-175,904);
     assign_angle_torsion(115,-175,1055);
     assign_angle_torsion(120,-175,845);
     assign_angle_torsion(125,-175,669);
     assign_angle_torsion(130,-175,534);
     assign_angle_torsion(135,-175,379);
     assign_angle_torsion(140,-175,178);
     assign_angle_torsion(145,-175,42);
     assign_angle_torsion(150,-175,3);
     assign_angle_torsion(155,-175,10);
     assign_angle_torsion(160,-175,0);
     assign_angle_torsion(165,-175,0);
     assign_angle_torsion(170,-175,0);
     assign_angle_torsion(175,-175,0);
}
 
void
AngleInfo::from_batched_angle_torsions_bits_185() {
 
     assign_angle_torsion(0,-180,0);
     assign_angle_torsion(5,-180,0);
     assign_angle_torsion(10,-180,0);
     assign_angle_torsion(15,-180,0);
     assign_angle_torsion(20,-180,0);
     assign_angle_torsion(25,-180,0);
     assign_angle_torsion(30,-180,0);
     assign_angle_torsion(35,-180,0);
     assign_angle_torsion(40,-180,0);
     assign_angle_torsion(45,-180,0);
     assign_angle_torsion(50,-180,0);
     assign_angle_torsion(55,-180,0);
     assign_angle_torsion(60,-180,0);
     assign_angle_torsion(65,-180,0);
     assign_angle_torsion(70,-180,0);
     assign_angle_torsion(75,-180,0);
     assign_angle_torsion(80,-180,3);
     assign_angle_torsion(85,-180,4);
     assign_angle_torsion(90,-180,21);
     assign_angle_torsion(95,-180,14);
     assign_angle_torsion(100,-180,41);
     assign_angle_torsion(105,-180,55);
     assign_angle_torsion(110,-180,95);
     assign_angle_torsion(115,-180,91);
     assign_angle_torsion(120,-180,69);
     assign_angle_torsion(125,-180,53);
     assign_angle_torsion(130,-180,51);
     assign_angle_torsion(135,-180,43);
     assign_angle_torsion(140,-180,11);
     assign_angle_torsion(145,-180,4);
     assign_angle_torsion(150,-180,0);
     assign_angle_torsion(155,-180,0);
     assign_angle_torsion(160,-180,0);
     assign_angle_torsion(165,-180,1);
     assign_angle_torsion(170,-180,0);
     assign_angle_torsion(175,-180,0);
}
