diff --git a/.gitattributes b/.gitattributes index 8654969d220..f757d907105 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1231,6 +1231,10 @@ Circular_kernel_2/Benchmarks/parser/Report.pdf -text svneol=unset#application/pd Circular_kernel_2/Benchmarks/readme.doc -text svneol=unset#application/msword Circular_kernel_2/Benchmarks/readme.pdf -text svneol=unset#application/pdf Circular_kernel_2/Benchmarks/readme.sxw -text +Circular_kernel_2/benchmark/parser/Report.pdf -text svneol=unset#application/pdf +Circular_kernel_2/benchmark/readme.doc -text svneol=unset#application/msword +Circular_kernel_2/benchmark/readme.pdf -text svneol=unset#application/pdf +Circular_kernel_2/benchmark/readme.sxw -text Circular_kernel_2/changes -text Circular_kernel_2/demo/Circular_kernel_2/Qt3/README -text Circular_kernel_2/demo/Circular_kernel_2/Qt3/help/get_arc.jpeg -text svneol=unset#image/jpeg diff --git a/Circular_kernel_2/benchmark/DxfArrayBenchmarks/Input_data.h b/Circular_kernel_2/benchmark/DxfArrayBenchmarks/Input_data.h new file mode 100644 index 00000000000..a0fa4516681 --- /dev/null +++ b/Circular_kernel_2/benchmark/DxfArrayBenchmarks/Input_data.h @@ -0,0 +1,124 @@ +#include +#include + +template +void _bench_input_dfx(ArcContainer& arcs,char* Dfxfile){ + + typedef typename CK::Circular_arc_2 Circular_arc_2; + typedef typename CK::Line_arc_2 Line_arc_2; + std::ifstream fin; + + fin.open (Dfxfile); + CGAL::variant_load(fin, std::back_inserter(arcs)); + fin.close(); +} + +template +void _bench_input_grid(ArcContainer& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 5; + int y = 5; + int r = 5; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j <20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } +} + +template +void _bench_input_grid2(ArcContainer& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back(Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } + + x += r; + y += r; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } + +} + +template +void _bench_input_random(ArcContainter& arcs) +{ + std::ofstream fout("random.inp"); + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + CGAL::Random generatorOfgenerator; + int random_seed = generatorOfgenerator.get_int(0, 123456); + std::cout << "random_seed = " << random_seed << std::endl; + CGAL::Random theRandom(random_seed); + + double random_max = 10; + double random_min = -10; + + for(int i = 0; i < 100 ; i++){ + double x = theRandom.get_double(random_min,random_max); + double y = theRandom.get_double(random_min,random_max); + double r = theRandom.get_double(0.1,random_max); + fout << x << " " << y << " " << r << " " ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + + fout.close(); + std::cout << arcs.size() << std::endl; + +} + +template +void _bench_input_file(ArcContainter& arcs){ + double x,y, r; + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + std::ifstream fin("random.inp"); + for(int i = 0; i < 100 ; i++){ + fin >> x >> y >> r ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + + fin.close(); +} + +template +void _bench_input_rotation(ArcContainter& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + int R =0; + + for(int k = 0; k < 5; k++){ + for(int i = 0; i < 5; i++){ + for(int j = 0; j < 5; j++){ + R = (r+k)*(r+k); + ac.push_back( Circle_2( Point_2(x + i*r, y + j*r),R)); + } + } + } + +} + diff --git a/Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmark.h b/Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmark.h new file mode 100644 index 00000000000..9a144bd89c5 --- /dev/null +++ b/Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmark.h @@ -0,0 +1,466 @@ +#ifndef ECG_BENCH_H +#define ECG_BENCH_H + +#include +#include + +#include +#include +#include +#include +#include +#include +#include "Input_data.h" +#include + + + +class Bench +{ +private: + + int numof_f_fails; + std::ofstream htmlout,texout; + struct rusage before,after; + struct timeval utime,stime; + bool firsttime; + int vert[5],hedg[5]; + int i; + CGAL::Memory_sizer mem_sizer; + char* Dxffile; + bool ONLY_DXF; + typedef std::list DxfFileNames; + bool Dxf_Horizontal; + double MemBefore,MemAfter; +public: + Bench(DxfFileNames df,char * fhtml="benchmarks.html", char* ftex="benchmarks.tex"): + htmlout(fhtml,std::ios::app), + texout(ftex,std::ios::app) + { + i=0; + numof_f_fails= CGAL::Interval_nt<>::number_of_failures() ; + ONLY_DXF = false; + Dxf_Horizontal =true; + std::cout << ".:Starting Bench Suite:." << std::endl; + std::cout << ".:Starting Bench Suite:." << std::endl; + + htmlout<<""<"; + texout << "\\documentclass[1pt]{article}"<"<<*it<<""; + texout <<"& \\multicolumn{4}{c|}{\\begin{verbatim}"<< *it<<"\\end{verbatim}}"; + }; + htmlout << "" + <::number_of_failures(); + Dxffile=Dxffilename; + ONLY_DXF = only_dxf; + + std::cout << ".:Starting Bench Suite:." << std::endl; + + htmlout<<"Dxf file is : "<< Dxffile << std::endl; + + htmlout<<"
Kernel
"<" + <" + <"<"; + texout<<" "; + } + + void close_cell(){ + htmlout <<""; + texout <<" "; + } + void open_row(){ + htmlout <<""; + texout <<""; + } + + void close_row(){ + htmlout <<""<< std::endl; + texout <<"\\\\ \\hline"<< std::endl; + } + + + void empty_cell(){ + this->open_cell(); + htmlout << "
Kernelgrid I(400 Circle_2)grid II(800 Circle_2)random double (100 Circle) rotation (125 Circle_2)
KernelDxf input is: "<< Dxffile <<"
" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter
" + <<"-"<<"" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "
" ; + texout<<"& -& -&-& -"; + this->close_cell(); + } + + void start(void){ + getrusage(RUSAGE_SELF,&before); + } + + void stop(void){ + getrusage(RUSAGE_SELF,&after); + } + + void summarize(int vertices,int hedges){ + int temp; + temp=CGAL::Interval_nt<>::number_of_failures(); + numof_f_fails = temp - numof_f_fails; + std::cout << " numbers_of_filter_fails : " << numof_f_fails << std::endl; + + timersub(&(after.ru_utime),&(before.ru_utime),&utime); + timersub(&(after.ru_stime),&(before.ru_stime),&stime); + + htmlout << "" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter
" + <" + << numof_f_fails << "" + << vertices << "" + << hedges<<"" + << MemBefore << "" + << MemAfter<< "
"; + + texout << " & " <::number_of_failures(); + } + + void fail(void){ + htmlout << ""<" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter" + <<"fail"<<"" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "
" ; + texout << "& fail & fail & fail & fail"; + std::cout << " :: Abort:: "<< std::endl; + } + + template + void arrangement(const ArcContainer & ac){ + bool fail=false; + typedef typename CGAL::Arrangement_2 Pmwx; + typedef typename CGAL::Arr_naive_point_location Point_location; + + std::cout << "memory size before construction" << mem_sizer.virtual_size() << std::endl; + std::cout << "memory resident size before insert()" << mem_sizer.resident_size () << std::endl; + MemBefore = mem_sizer.virtual_size ()/1000; + Pmwx _pm; + Point_location _pl(_pm); + + try{ + this->start(); + insert(_pm,ac.begin(),ac.end(),boost::false_type()); + this->stop(); + } + catch (...) { + this->fail(); + fail=true; + } + vert[i]=(int)_pm.number_of_vertices(); + hedg[i]=(int)_pm.number_of_halfedges(); + + if (!fail){this->summarize(_pm.number_of_vertices(),_pm.number_of_halfedges());} + + MemAfter = mem_sizer.virtual_size ()/1000; + std::cout << "memory size after insert()" << mem_sizer.virtual_size () << std::endl; + std::cout << "memory resident size after insert()" << mem_sizer.resident_size () << std::endl; + _pm.clear(); + + } + + + +template + void grid(){ + i=1; + ArcContainer ac; + _bench_input_grid(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + + template + void grid2(){ + i=2; + ArcContainer ac; + _bench_input_grid2(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + + template + void random(){ + i=3; + ArcContainer ac; + if (firsttime){ + _bench_input_random(ac); + std::cout << "Input from random generator!"<(ac); + std::cout << "Input from file!"<open_cell(); + this->arrangement(ac); + this->close_cell(); + firsttime = false; + } + + template + void dfx(char* Dfxfile){ + if(!Dxf_Horizontal){ + i=4; + } + ArcContainer arc; + _bench_input_dfx(arc,Dfxfile); + this->open_cell(); + this->arrangement(arc); + this->close_cell(); + } + + template + void rotation(){ + i=5; + bool fail=false; + ArcContainer arc; + try{ + _bench_input_rotation(arc); + } + catch (...) + { + this->fail(); + fail=true; + std::cout << "failed before input"; + } + + if (!fail){ + this->open_cell(); + this->arrangement(arc); + this->close_cell(); + this->close_row(); + } + } +public: + template + void Compute(char* dxffile){ + if(!ONLY_DXF){ + this->grid(); + this->grid2(); + this->random(); + this->dfx(dxffile); + this->rotation(); + } + else{ + this->dfx(dxffile); + this->close_row(); + } + } + template + void ComputeArrayDxf(DxfFileNames df){ + i=0; + for ( DxfFileNames::const_iterator it=df.begin(); + it != df.end(); ++it) { + std::cout<<*it<dfx(*it); + i++; + }; + this->close_row(); + } + template + void Compute_no_dxf(){ + if(!ONLY_DXF){ + this->grid(); + this->grid2(); + this->random(); + this->empty_cell(); + this->rotation(); + } + } + + void empty_row(){ + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->close_row(); + } + +template + void Compute_dxf(char* dxffile){ + this->dfx(dxffile); + this->close_row(); + } + + void kernel(char* kernel){ + this->open_row(); + this->open_cell(); + htmlout << kernel; + texout << kernel ; + this->close_cell(); + } + + + void newDxfFilename(char* Dxffilename=""){ + char* newDxf = Dxffilename; + if(!Dxf_Horizontal){ + if(!ONLY_DXF){ + htmlout<< "Kernelgrid Igrid IIrandom doubleDxf input is: "<< newDxf <<" rotation " + <KernelDxf input is: "<< newDxf <<" " + <"<"<"<Kernel"; + for (DxfFileNames::const_iterator it=df.begin(); + it != df.end(); ++it) { + std::cout<<*it<"<<*it<<""; + texout <<"& \\multicolumn{4}{c|}{\\begin{verbatim}"<< *it<<"\\end{verbatim}}"; + }; + htmlout << "" + < +#include +#include + +#include + +#include + +#include + +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + + +#include +#include + +#include "benchmark.h" + +int main(int argc, char* argv[]) +{ typedef std::list Dxffilenames; + Dxffilenames dxffilenames; + char* Dxffilename[]={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","mask1.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","cad_l2.dxf","cad_l1.dxf","CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"}; + char* Htmlfilename; + char* Texfilename; + int i; + i=0; + + + Htmlfilename="benchmarks.html"; + Texfilename="benchmarks.tex"; + + +for(int n = 0; n < 3; n++){ + dxffilenames.push_back(Dxffilename[n]); + }; + + + Bench bench(dxffilenames,Htmlfilename,Texfilename); + + +for(i=1;i<6;i++){ + + + +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Circular_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef CIRCULAR_KERNEL_2 + typedef CGAL::Quotient NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CircularKernel; + + typedef CircularKernel::Circular_arc_2 Circular_arc_2; + typedef CircularKernel::Line_arc_2 Line_arc_2; + typedef CGAL::Variant_traits CircularK_Variant_Traits; + + typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; + typedef std::vector CircularKVarArcContainer; + + bench.kernel("CK VarTraits"); + + bench.ComputeArrayDxf(dxffilenames); + +//bench.Compute_dxf(Dxffilename[i]); + + #endif +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2 +// typedef CGAL::Quotient NT2; + typedef CGAL::Gmpq NT2; + typedef CGAL::Cartesian Linear_k2; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k2; + typedef CGAL::Circular_kernel_2 CK2_; + + + typedef CGAL::Interval_nt_advanced NT3; + typedef CGAL::Cartesian Linear_k3; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k3; + typedef CGAL::Circular_kernel_2 CK3_; + + + typedef CGAL::Lazy_circular_kernel_2 LazyCurvedK; + + + + typedef LazyCurvedK::Circular_arc_2 Circular_arc_3; + typedef LazyCurvedK::Line_arc_2 Line_arc_3; + typedef boost::variant LazyVarArc; + typedef std::vector LazyVarContainer; + typedef CGAL::Variant_traits LazyCurvedK_Variant_Traits; + + bench.kernel("LazyK. VarTraits"); + + bench.ComputeArrayDxf(dxffilenames); + //bench.Compute_dxf(Dxffilename[i]); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON + + typedef CGAL::Filtered_hexagon_circular_kernel_2 CircularKernelHexagon; + + typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4; + typedef CircularKernelHexagon::Line_arc_2 Line_arc_4; + typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc; + typedef std::vector CircularKernHexVarArcContainer; + typedef CGAL::Variant_traits CircularKernHex_Variant_Traits; + + bench.kernel("CK Hex VarTraits"); + + // bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON + + typedef CGAL::Filtered_hexagon_curved_kernel LazyKernelHexagon; + + typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5; + typedef LazyKernelHexagon::Line_arc_2 Line_arc_5; + typedef boost::variant HxLazyVarArc; + typedef std::vector HxLazyVarContainer; + typedef CGAL::Variant_traits HxLazyVariantTraits; + + bench.kernel("LazyK Hex VarTraits") ; + + //bench.Compute(Dxffilename[i]); +bench.Compute_no_dxf(); + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef CIRCULAR_KERNEL_2_FILTERED_BBOX + + typedef CGAL::Filtered_bbox_circular_kernel_2 BBCircularKernel ; + + typedef BBCircularKernel::Circular_arc_2 Circular_arc_6; + typedef BBCircularKernel::Line_arc_2 Line_arc_6; + typedef boost::variant BBCircVarArc; + typedef std::vector BBCircVarContainer; + typedef CGAL::Variant_traits BBCircVariantTraits; + + bench.kernel("CK BBox VarTraits") ; + + bench.Compute(Dxffilename[i]); + // bench.Compute_no_dxf(); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2_FILTERED_BBOX + + typedef CGAL::Filtered_bbox_curved_kernel BBLazyCurvedK; + + typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7; + typedef BBLazyCurvedK::Line_arc_2 Line_arc_7; + typedef boost::variant BBLazyVarArc; + typedef std::vector< BBLazyVarArc> BBLazyVarContainer; + typedef CGAL::Variant_traits BBLazyVariantTraits; + + bench.kernel("LLazyK BBox VarTraits") ; + + bench.Compute(Dxffilename[i]); + //bench.Compute_no_dxf(); + + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircKHexagon ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircKHexagonCATraits; + #else + typedef CGAL::Circular_arc_traits Traits0_7; + typedef CGAL::Circular_arc_traits_tracer BBCircKHexagonCATraits; + #endif + typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc; + typedef std::vector BBCircKHexagonArcCont; + bench.kernel("BBox Circular kernel filtered Hexagon CircArcTraits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8; + typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8; + typedef boost::variant BBCircularKernelHexagonVarArc; + typedef std::vector BBCircularKernelHexagonVarContainer; + typedef CGAL::Variant_traits BBCircularKernelHexagonVariantTraits; + + bench.kernel("BBox Circular kernel filtered Hexagon VarTraits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf();*/ + /*-------------------------------------------------------------------------------------------------------------------------- + -----------------------------------------------------------------------------------------------------------------------------*/ +dxffilenames.erase(dxffilenames.begin(),dxffilenames.end()); +if (i<5){ +for(int n = 3*(i+1)-3; n < 3*(i+1); n++){ + dxffilenames.push_back(Dxffilename[n]); + }; + bench.newDxfArray(dxffilenames); + } + } + + return 0; +}; + + diff --git a/Circular_kernel_2/benchmark/Input_data.h b/Circular_kernel_2/benchmark/Input_data.h new file mode 100644 index 00000000000..3c9f9d34b1b --- /dev/null +++ b/Circular_kernel_2/benchmark/Input_data.h @@ -0,0 +1,124 @@ +#include +#include + +template +void _bench_input_dfx(ArcContainer& arcs,char* Dfxfile){ + + typedef typename CK::Circular_arc_2 Circular_arc_2; + typedef typename CK::Line_arc_2 Line_arc_2; + std::ifstream fin; + + fin.open (Dfxfile); + CGAL::variant_load(fin, std::back_inserter(arcs)); + fin.close(); +} + +template +void _bench_input_grid(ArcContainer& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 5; + int y = 5; + int r = 5; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j <20; j++){ + ac.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x + j*r, y + i*r), r*r))); + } + } +} + +template +void _bench_input_grid2(ArcContainer& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x + j*r, y + i*r), r*r) )); + } + } + + x += r; + y += r; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x + j*r, y + i*r), r*r))); + } + } + +} + +template +void _bench_input_random(ArcContainter& arcs) +{ + std::ofstream fout("random.inp"); + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + CGAL::Random generatorOfgenerator; + int random_seed = generatorOfgenerator.get_int(0, 123456); + std::cout << "random_seed = " << random_seed << std::endl; + CGAL::Random theRandom(random_seed); + + double random_max = 10; + double random_min = -10; + + for(int i = 0; i < 100 ; i++){ + double x = theRandom.get_double(random_min,random_max); + double y = theRandom.get_double(random_min,random_max); + double r = theRandom.get_double(0.1,random_max); + fout << x << " " << y << " " << r << " " ; + arcs.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x,y), r*r) )); + } + + fout.close(); + std::cout << arcs.size() << std::endl; + +} + +template +void _bench_input_file(ArcContainter& arcs){ + double x,y, r; + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + std::ifstream fin("random.inp"); + for(int i = 0; i < 100 ; i++){ + fin >> x >> y >> r ; + arcs.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x,y), r*r))); + } + + fin.close(); +} + +template +void _bench_input_rotation(ArcContainter& ac){ + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + int R =0; + + for(int k = 0; k < 5; k++){ + for(int i = 0; i < 5; i++){ + for(int j = 0; j < 5; j++){ + R = (r+k)*(r+k); + ac.push_back(typename CK::Circular_arc_2 ( Circle_2( Point_2(x + i*r, y + j*r),R) )); + } + } + } + +} + diff --git a/Circular_kernel_2/benchmark/README_benchmark_CK2.txt b/Circular_kernel_2/benchmark/README_benchmark_CK2.txt new file mode 100644 index 00000000000..4076e84b275 --- /dev/null +++ b/Circular_kernel_2/benchmark/README_benchmark_CK2.txt @@ -0,0 +1,78 @@ +The usage is: +./example ${alpha} ${beta} + +where alpha: +1: means to bench the BBox(CK) with Vartraits +2: means to bench the Lazy(CK) with Vartraits +3: means to bench the CK with Vartraits +4: means to bench the Bbox(Lazy(CK)) with Vartraits +5: means to bench the BBox(CK) with Circulartraits +6: means to bench the Lazy(CK) with Circulartraits +7: means to bench the CK(CK) with Circulartraits +8: means to bench the Bbox(Lazy(CK)) Circulartraits +(le 0 est interne) + +beta: +0: Compute the arrangement of DXF/51.dxf with the kernel ${alpha} +1: Compute the arrangement of DXF/cad_l1.dxf with the kernel ${alpha} +2: Compute the arrangement of DXF/cad_l2.dxf +3: Compute the arrangement of DXF/che_mod1.dxf +4: Compute the arrangement of DXF/CIOnZDraw.dxf +5: Compute the arrangement of DXF/mask1.dxf +6: Compute the arrangement of DXF/elekonta.dxf +7: Compute the arrangement of DXF/netlist_signal_1.dxf +8: Compute the arrangement of DXF/painttrack.dxf +9: Compute the arrangement of ${Scenario1} +a: Compute the arrangement of ${Scenario2} +b: Compute the arrangement of ${Scenario3} +c: Compute the arrangement of ${Scenario4} +d: Compute the arrangement of ${Scenario5} + +${Scenario1}: +- Circles with center in [0,10]x[0,10], +- 0.5 of distance between each circle +- unitary radius + +${Scenario2}: +- Circles with center in [0,0.2]x[0,0.2], +- 0.01 of distance between each circle +- unitary radius + +${Scenario3}: +Only one circle + +${Scenario4} +100 Random Circles with +- Center in [0,1]x[0,1] +- Radius in [0,1] + +${Scenario5} +Lattice, like: +o o o o o o o o o o o o o o o o + o o o o o o o o o o o o o o o +o o o o o o o o o o o o o o o o + o o o o o o o o o o o o o o o +o o o o o o o o o o o o o o o o + o o o o o o o o o o o o o o o +with no intersection. + +The output: + +In std::cout : +The number of elements to compute the arrangement +The number of circles and polygons (wich the side may be circular arcs) +The time needed to compute it, +The number of Vertices, Edges and Faces of the arrangement + +In std::cerr : +Only the time needed to compute it. (it is useful to benchmark a lot of cases and redirect it on a .txt) + +ATTENTION: +1) dont use ./example a b +with 5 <= a <= 8 and 0 <= b <= 8, we cannot use the Circulartraits to handle the files +2) The files have to be put on a folder name DXF where the program is located + +Compile with -DCGAL_INTERSECTION_MAP_FOR_SUPPORTING_CIRCLES if you want to benchmark with +the same kernel, but with an additional map for supporting circles. + + diff --git a/Circular_kernel_2/benchmark/arrangement_traits/Input_data.h b/Circular_kernel_2/benchmark/arrangement_traits/Input_data.h new file mode 100644 index 00000000000..1ed39661fa0 --- /dev/null +++ b/Circular_kernel_2/benchmark/arrangement_traits/Input_data.h @@ -0,0 +1,140 @@ +#include +#include + +template +void _bench_input_dfx(ArcContainer& arcs,char* Dfxfile){ +std::ifstream fin; +fin.open (Dfxfile); + typedef typename CK::Circular_arc_2 Circular_arc_2; + typedef typename CK::Line_arc_2 Line_arc_2; +CGAL::variant_load(fin, std::back_inserter(arcs)); +fin.close(); +} + +template +void _bench_input_grid(ArcContainer& ac){ + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + int x = 5; + int y = 5; + int r = 5; + for(int i = 0; i < 20; i++){ + for(int j = 0; j <20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } +// CGAL::Random theRandom(77147); +// double random_max = 15; +// double random_min = -16; +// for(int i = 0; i < 100 ; i++){ +// double x1, y1, x2, y2 = 0.0; +// do{ +// x1 = theRandom.get_double(random_min,random_max); +// y1 = theRandom.get_double(random_min,random_max); +// x2 = theRandom.get_double(random_min,random_max); +// y2 = theRandom.get_double(random_min,random_max); +// }while ((x1 == x2) && (y1 == y2)); +// ac.push_back( Line_arc_2( Point_2(x1,y1), Point_2(x2, y2))); +// } +} + +template +void _bench_input_grid2(ArcContainer& ac) +{ + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back(Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } + + x += r; + y += r; + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } +} + +template +void _bench_input_random(ArcContainter& arcs) +{ + std::ofstream fout("random.inp"); + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + + CGAL::Random generatorOfgenerator; + int random_seed = generatorOfgenerator.get_int(0, 123456); + std::cout << "random_seed = " << random_seed << std::endl; + + CGAL::Random theRandom(random_seed); +// CGAL::Random theRandom(77147); + double random_max = 10; + double random_min = -10; + + for(int i = 0; i < 100 ; i++){ + double x = theRandom.get_double(random_min,random_max); + double y = theRandom.get_double(random_min,random_max); + double r = theRandom.get_double(0.1,random_max); + fout << x << " " << y << " " << r << " " ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + fout.close(); +// for(int i = 0; i < 20 ; i++){ +// double x1, y1, x2, y2 = 0.0; +// do{ +// x1 = theRandom.get_double(random_min,random_max); +// y1 = theRandom.get_double(random_min,random_max); +// x2 = theRandom.get_double(random_min,random_max); +// y2 = theRandom.get_double(random_min,random_max); +// }while ((x1 == x2) && (y1 == y2)); +// arcs.push_back( Line_arc_2( Point_2(x1,y1), Point_2(x2, y2))); +// } +// + std::cout << arcs.size() << std::endl; + +} +template +void _bench_input_file(ArcContainter& arcs) +{ double x,y, r; + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + std::ifstream fin("random.inp"); + for(int i = 0; i < 100 ; i++){ + // fin >> x >> y >> r ; + fin >> x >> y >> r ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + fin.close(); +} + +template +void _bench_input_rotation(ArcContainter& ac) +{ +typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + int x = 10; + int y = 10; + int r = 10; + int R =0; +for(int k = 0; k < 5; k++){ + for(int i = 0; i < 5; i++){ + for(int j = 0; j < 5; j++){ + R = (r+k)*(r+k); + ac.push_back( Circle_2( Point_2(x + i*r, y + j*r),R)); + } + } +} + +} + diff --git a/Circular_kernel_2/benchmark/arrangement_traits/IntStr.h b/Circular_kernel_2/benchmark/arrangement_traits/IntStr.h new file mode 100644 index 00000000000..18265cb975a --- /dev/null +++ b/Circular_kernel_2/benchmark/arrangement_traits/IntStr.h @@ -0,0 +1,23 @@ + +#include +#include + +template +bool from_string(T &t, + const std::string &s, + std::ios_base & (*f)(std::ios_base&)) +{ + std::istringstream iss(s); + return !(iss>>f>>t).fail(); +} + + +template +std::string to_string(T t, std::ios_base & (*f)(std::ios_base&)=std::dec) +{ + std::ostringstream oss; + oss << f << t; + return oss.str(); +} + + diff --git a/Circular_kernel_2/benchmark/arrangement_traits/benchmark.h b/Circular_kernel_2/benchmark/arrangement_traits/benchmark.h new file mode 100644 index 00000000000..9ba0d3c9522 --- /dev/null +++ b/Circular_kernel_2/benchmark/arrangement_traits/benchmark.h @@ -0,0 +1,379 @@ +#ifndef ECG_BENCH_H +#define ECG_BENCH_H + +#include +#include + +#include +#include +#include +#include +#include +#include +#include "Input_data.h" +#include + +class Bench +{ + int numof_f_fails; + std::ofstream htmlout,texout; + struct rusage before,after; + struct timeval utime,stime; + bool firsttime; + char *description; + int vert[4],hedg[4]; + int i; + CGAL::Memory_sizer mem_sizer; + char* Dxffile; + bool ONLY_DXF; + + + public: + + Bench( char *fhtml="benchmarks.html", char* ftex="benchmarks.tex",char* Dxffilename="",const bool only_dxf=false): + htmlout(fhtml,std::ios::app), + texout(ftex,std::ios::app) + { i=0; + numof_f_fails= 0; + Dxffile=Dxffilename; + ONLY_DXF = only_dxf; + + description = "Arrangement "; + + std::cout << ".:Starting Bench Suite:." << std::endl; + std::cout << "bencmarking : " << description << std::endl; + + htmlout<<"Dxf file is : "<< Dxffile << std::endl; + htmlout<<""<" + <" + <"<"; + texout<<" "; + } + void close_cell() + { + htmlout <<""; + texout <<" "; + } + void open_row() + { + htmlout <<""; + texout <<""; + } + void close_row() + { + htmlout <<""<< std::endl; + texout <<"\\\\ \\hline"<< std::endl; + } + + void kernel(char* kernel) + { this->open_row(); + this->open_cell(); + htmlout << kernel; + texout << kernel ; + this->close_cell(); + } + + void empty_cell() + { + this->open_cell(); + htmlout << "
Kernelgrid I(400 Circle_2)grid II(800 Circle_2)random double (100 Circle)Dxf input. Dxf file is : "<< Dxffile <<" rotation (125 Circle_2)
KernelDxf input. Dxf file is : "<< Dxffile <<"
" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedges
" + <<"-"<<"" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "
" ; + texout<<"& -"; + this->close_cell(); + } + + void infotable(){ + + texout<< "\\hline\\hline & grid I&grid II &random double & Dxf input. Dxf file is : "<< Dxffile <<" & rotation \\\\ \\hline" << std::endl + << "vertices" ; + for (int k=1; k < 6 ;k++) + { + texout << " & "<< vert[k]; + } + texout<<"\\\\ \\hline"<Kernelgrid Igrid IIrandom doubleDxf input. Dxf file is : "<< Dxffile <<" rotation " + <KernelDxf input. Dxf file is : "<< Dxffile <<" " + <::number_of_failures(); + numof_f_fails = temp - numof_f_fails; + + std::cout << " numbers_of_filter_fails : " << numof_f_fails << std::endl; + timersub(&(after.ru_utime),&(before.ru_utime),&utime); + timersub(&(after.ru_stime),&(before.ru_stime),&stime); + + htmlout << "" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedges
" + <" + << numof_f_fails << "" + << vertices << "" + << hedges<< "
"; + + texout << " & " <::number_of_failures(); + } + + void fail(void) + { + htmlout << "" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedges
" + <<"fail"<<"" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "
" ; + texout << "&" <<"fail"; + std::cout << " :: Abort:: "<< std::endl; + } + + template + void arrangement(const ArcContainer & ac){ + bool fail=false; + typedef typename CGAL::Arrangement_2 Pmwx; + typedef typename CGAL::Arr_naive_point_location Point_location; + std::cout << "memory size before construction" << mem_sizer.virtual_size() << std::endl; + std::cout << "memory resident size before insert()" << mem_sizer.resident_size () << std::endl; + Pmwx _pm; + Point_location _pl(_pm); + + std::cout << "Construction complited"<start(); + + insert(_pm,ac.begin(),ac.end(),boost::false_type()); + + this->stop(); + } + catch (...) { + this->fail(); + fail=true; + } + vert[i]=(int)_pm.number_of_vertices(); + hedg[i]=(int)_pm.number_of_halfedges(); + + + //_pl.~Point_location(); + // _pm.~Pmwx(); + if (!fail){this->summarize(_pm.number_of_vertices(),_pm.number_of_halfedges());} + + + std::cout << "memory size after insert()" << mem_sizer.virtual_size () << std::endl; + std::cout << "memory resident size after insert()" << mem_sizer.resident_size () << std::endl; + } + + + +template + void grid(){ + + i=1; + + ArcContainer ac; + + _bench_input_grid(ac); + + this->open_cell(); + + this->arrangement(ac); + + this->close_cell(); + } + + template + void grid2(){ + i=2; + + ArcContainer ac; + + _bench_input_grid2(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + template + void random() + { + i=3; + + ArcContainer ac; + if (firsttime) + { + _bench_input_random(ac); + std::cout << "Input from random generator!"<(ac); + std::cout << "Input from file!"<open_cell(); + this->arrangement(ac); + this->close_cell(); + firsttime = false; + } + template + void dfx(char* Dfxfile){ + i=4; + + ArcContainer arc; + _bench_input_dfx(arc,Dfxfile); + this->open_cell(); + this->arrangement(arc); + + this->close_cell(); + + } + + template + void rotation(){ + i=5; + + ArcContainer arc; + try{ + + _bench_input_rotation(arc); + } + catch (...) + { + std::cout << "failed before input"; + } + this->open_cell(); + this->arrangement(arc); + + this->close_cell(); + + this->close_row(); + } + + template + void Compute(char* dxffile) + { + this->grid(); + + this->grid2(); + + this->random(); +// this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); + + this->dfx(dxffile); + + this->rotation(); + //this->empty_cell(); + //this->close_row(); + + } + + template + void Compute_no_dxf() + { + this->grid(); + + + this->grid2(); + + this->random(); + this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->close_row(); + this->rotation(); + } + + void empty_row() + { this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->close_row(); + + } + template + void Compute_dxf(char* dxffile) + { + this->dfx(dxffile); + this->close_row(); + } +}; + +#endif //#define ECG_BENCH_H + diff --git a/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrangement.cpp b/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrangement.cpp new file mode 100644 index 00000000000..10a44b21aa8 --- /dev/null +++ b/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrangement.cpp @@ -0,0 +1,463 @@ +#define CGAL_CAST_INT + +#include +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + + +#include +#include + +#include "benchmark.h" + +int main(int argc, char* argv[]) +{ + char* Dxffilename[15]/*={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","cad_l2.dxf","cad_l1.dxf","CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"}*/; + char* Htmlfilename; + char* Texfilename; + char exten[4]; + int i; + i=0; + + +if (argv[1] != NULL) + { + int len =strlen(argv[1]); + for (int j=0; j < 3 ; j++) + { + exten[j]=argv[1][len - 3 + j]; + } + if (strncmp(exten,"dxf",3) !=0) + { + std::cout<< "File is not correct (*.dxf is needed)." << std::endl; + return 0; + } + else{ + Dxffilename[i] = argv[1]; + std::cout<< "File "<< Dxffilename[i] << " is correct."<2 and argv[2] != NULL) + { + int len =strlen(argv[2]); + for (int j=0; j < 4 ; j++) + { + exten[j]=argv[2][len - 4 + j]; + } + if (strncmp(exten,"html",4) !=0) + { + std::cout<< "File "<< argv[2] << " is not correct (*.html is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[2] << " is correct." < > NT4; +// typedef CGAL::Cartesian Linear_k4; +// typedef CGAL::Algebraic_kernel_2_2 Algebraic_k4; +// typedef CGAL::Curved_kernel CK4; +// +// #ifndef CGAL_CURVED_KERNEL_DEBUG +// typedef CGAL::Circular_arc_traits CircularK_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0; +// typedef CGAL::Circular_arc_traits_tracer CircularK_CA_Traits; +// #endif +// +// typedef CK4::Circular_arc_2 CircularKArc; +// typedef std::vector CircularKArcContainer; +// bench.kernel("Circular kernel Circular arc traits"); +// +// typedef CircularK_CA_Traits::Curve_2 Conic_arc_2; +// typedef CGAL::Arrangement_2 Pmwx; +// typedef CGAL::Arr_naive_point_location Point_location; +// +// typedef CircularK_CA_Traits::X_monotone_curve_2 X_monotone_curve_2; +// typedef CK4::Point_2 Point_2; +// typedef CK4::Circle_2 Circle_2; +// typedef CK4::Circular_arc_2 Circular_arc_2; +// +// +// CGAL::Random generatorOfgenerator; +// int random_seed = generatorOfgenerator.get_int(0, 123456); +// std::cout << "random_seed = " << random_seed << std::endl; +// CGAL::Random theRandom(random_seed); +// int random_max = 128; +// int random_min = -128; +// CircularKArcContainer ac; +// int x; +// int y; +// int r; +// for(int i = 0; i < 20; i++){ +// x = theRandom.get_int(random_min,random_max); +// y = theRandom.get_int(random_min,random_max); +// r = theRandom.get_int(1,random_max); +// ac.push_back( Circle_2( Point_2(x,y), r*r)); +// } +// +// // Pmwx _pm; +// // Point_location _pl(_pm); +// // try{ +// // bench.start(); +// // for (typename ArcContainer::const_iterator it=ac.begin(); +// // it != ac.end(); ++it) { +// // //insert(_pm,_pl,*it); +// // insert(_pm,*it,_pl); +// // }; +// // bench.stop(); +// // bench.summarize(_pm.number_of_vertices(),_pm.number_of_halfedges()); +// // } +// // catch (...) { +// // bench.fail(); +// // } +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Circular_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + + typedef CGAL::Quotient NT1; + //typedef CGAL::Lazy_exact_nt > NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CircularKernel; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits CircularK_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0; + typedef CGAL::Circular_arc_traits_tracer CircularK_CA_Traits; + #endif + + typedef CircularKernel::Circular_arc_2 CircularKArc; + typedef std::vector CircularKArcContainer; + bench.kernel("Circular kernel Circular arc traits"); + + bench.Compute_no_dxf(); + + + typedef CircularKernel::Circular_arc_2 Circular_arc_2; + typedef CircularKernel::Line_arc_2 Line_arc_2; + typedef CGAL::Variant_traits CircularK_Variant_Traits; + + typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; + typedef std::vector CircularKVarArcContainer; + + bench.kernel("Circular kernel Variant traits"); + + bench.Compute(Dxffilename[i]); + // bench.Compute_dxf(Dxffilename[i]); + +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Quotient NT2; + // typedef CGAL::Lazy_exact_nt > NT2; + typedef CGAL::Cartesian Linear_k2; + typedef CGAL::Algebraic_kernel_2_2 Algebraic_k2; + typedef CGAL::Curved_kernel CK2_; + + //typedef CGAL::Interval_nt<> NT2; + typedef CGAL::Interval_nt_advanced NT3; + typedef CGAL::Cartesian Linear_k3; + typedef CGAL::Algebraic_kernel_2_2 Algebraic_k3; + typedef CGAL::Curved_kernel CK3_; + + + typedef CGAL::Lazy_curved_kernel LazyCurvedK; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits LazyCurvedK_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_2; + typedef CGAL::Circular_arc_traits_tracer LazyCurved_kTraits; + #endif + + typedef LazyCurvedK::Circular_arc_2 LazyArc; + typedef std::vector LazyArcContainer; + + bench.kernel("Lazy curved kernel Circular arc traits") ; + + bench.Compute_no_dxf(); + + + typedef LazyCurvedK::Circular_arc_2 Circular_arc_3; + typedef LazyCurvedK::Line_arc_2 Line_arc_3; + typedef boost::variant LazyVarArc; + typedef std::vector LazyVarContainer; + typedef CGAL::Variant_traits LazyCurvedK_Variant_Traits; + + bench.kernel("Lazy curved kernel Variant traits"); + + bench.Compute(Dxffilename[i]); + //bench.Compute_dxf(Dxffilename[i]); + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + +/* + typedef CGAL::Filtered_hexagon_curved_kernel CircularKernelHexagon; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits CircularKernHex_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_3; + typedef CGAL::Circular_arc_traits_tracer CircularKernHex_CA_Traits; + #endif + + typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc; + typedef std::vector CircularKernHexArcContainer; + bench.kernel("Circular kernel filtered hexagon Circular arc traits"); + + bench.Compute_no_dxf(); + + + typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4; + typedef CircularKernelHexagon::Line_arc_2 Line_arc_4; + typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc; + typedef std::vector CircularKernHexVarArcContainer; + typedef CGAL::Variant_traits CircularKernHex_Variant_Traits; + + bench.kernel("Circular kernel filtered hexagon Variants traits"); + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + + + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_hexagon_curved_kernel LazyKernelHexagon; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits LazyKernelHexagon_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_4; + typedef CGAL::Circular_arc_traits_tracer LazyKernelHexagon_CA_Traits; + #endif + typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc; + typedef std::vector LazyKernelHexagonArcContainer; + bench.kernel("Lazy curved kernel filtered hexagon Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5; + typedef LazyKernelHexagon::Line_arc_2 Line_arc_5; + typedef boost::variant HxLazyVarArc; + typedef std::vector HxLazyVarContainer; + typedef CGAL::Variant_traits HxLazyVariantTraits; + + bench.kernel("Lazy curved kernel filtered hexagon Variants traits") ; + + //bench.Compute(Dxffilename[i]); +bench.Compute_no_dxf(); + + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircularKernel ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircularKernel_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_5; + typedef CGAL::Circular_arc_traits_tracer BBCircularKernel_CA_Traits; + #endif + typedef BBCircularKernel::Circular_arc_2 BBCircularKernelArc; + typedef std::vector BBCircularKernelArcContainer; + bench.kernel("Circular kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernel::Circular_arc_2 Circular_arc_6; + typedef BBCircularKernel::Line_arc_2 Line_arc_6; + typedef boost::variant BBCircVarArc; + typedef std::vector BBCircVarContainer; + typedef CGAL::Variant_traits BBCircVariantTraits; + + bench.kernel("Circular kernel filtered bbox Variants traits") ; + + // bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBLazyCurvedK; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBLazyCurvedK_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_6; + typedef CGAL::Circular_arc_traits_tracer BBLazyCurvedK_CA_Traits; + #endif + typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc; + typedef std::vector BBLazyCurvedKArcContainer; + bench.kernel("Lazy curved kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + + typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7; + typedef BBLazyCurvedK::Line_arc_2 Line_arc_7; + typedef boost::variant BBLazyVarArc; + typedef std::vector< BBLazyVarArc> BBLazyVarContainer; + typedef CGAL::Variant_traits BBLazyVariantTraits; + + bench.kernel("Lazy curved kernel filtered bbox Variants traits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircKHexagon ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircKHexagonCATraits; + #else + typedef CGAL::Circular_arc_traits Traits0_7; + typedef CGAL::Circular_arc_traits_tracer BBCircKHexagonCATraits; + #endif + typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc; + typedef std::vector BBCircKHexagonArcCont; + bench.kernel("BBox Circular kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8; + typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8; + typedef boost::variant BBCircularKernelHexagonVarArc; + typedef std::vector BBCircularKernelHexagonVarContainer; + typedef CGAL::Variant_traits BBCircularKernelHexagonVariantTraits; + + bench.kernel("BBox Circular kernel filtered bbox Variants traits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf();*/ + /*-------------------------------------------------------------------------------------------------------------------------- + -----------------------------------------------------------------------------------------------------------------------------*/ + if (i+1<15) + { + if (strcmp(Dxffilename[i+1],"")) + { + bench.newDxfFilename(Dxffilename[i+1]); + } + else + { + std::cout << "that's all" << Dxffilename[i+1] << std::endl; + break; + } + } + } + +bench.infotable(); + + return 0; +} + diff --git a/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrengement_traits.cpp b/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrengement_traits.cpp new file mode 100644 index 00000000000..92d76a48f50 --- /dev/null +++ b/Circular_kernel_2/benchmark/arrangement_traits/benchmarks_arrengement_traits.cpp @@ -0,0 +1,151 @@ +#include + +#include +#include +#include + +#include + +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + + +#include +#include "benchmark.h" + +#include +#include "IntStr.h" +int main(int argc, char* argv[]) +{ char* Dxffilename; + char* Htmlfilename; + char* Texfilename; + char exten[4]; + + + +if (argv[1] != NULL) + { + int len =strlen(argv[1]); + for (int j=0; j < 3 ; j++) + { + exten[j]=argv[1][len - 3 + j]; + } + if (strncmp(exten,"dxf",3) !=0) + { + std::cout<< "File is not correct (*.dxf is needed)." << std::endl; + return 0; + } + else{ + Dxffilename = argv[1]; + std::cout<< "File "<< Dxffilename << " is correct."<2 and argv[2] != NULL) + { + int len =strlen(argv[2]); + for (int j=0; j < 4 ; j++) + { + exten[j]=argv[2][len - 4 + j]; + } + if (strncmp(exten,"html",4) !=0) + { + std::cout<< "File "<< argv[2] << " is not correct (*.html is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[2] << " is correct." < Rat_kernel; +typedef CGAL::Cartesian Alg_kernel; +typedef CGAL::Arr_conic_traits_2 Traits_2; + +typedef Traits_2::Curve_2 Conic_arc_2; +typedef Traits_2::Polygon_2 Polygon; +bench.kernel("Arrangement_traits"); + +typedef std::vector ArcContainer; + +bench.Compute_no_dxf(); + + +bench.infotable(); + + return 0; +} + + + + diff --git a/Circular_kernel_2/benchmark/benchmark.h b/Circular_kernel_2/benchmark/benchmark.h new file mode 100644 index 00000000000..ebc5e887648 --- /dev/null +++ b/Circular_kernel_2/benchmark/benchmark.h @@ -0,0 +1,388 @@ +#ifndef ECG_BENCH_H +#define ECG_BENCH_H + +#include +#include + +#include +#include +#include +#include +#include +#include +#include "Input_data.h" +#include +#include + + + +class Bench +{ +private: + + int numof_f_fails; + std::ofstream htmlout,texout; + struct rusage before,after; + struct timeval utime,stime; + bool firsttime; + int vert[4],hedg[4]; + int i; +typedef std::size_t size_type; + CGAL::Memory_sizer mem_sizer; + std::string Dxffile; + bool ONLY_DXF; + double MemBefore,MemAfter; + +public: + + Bench(const bool only_dxf=false, const char *fhtml="benchmarks.html", const char* ftex="benchmarks.tex",const char* Dxffilename=""): + htmlout(fhtml,std::ios::app), + texout(ftex,std::ios::app){ + i=0; + numof_f_fails= 0; + Dxffile=Dxffilename; + ONLY_DXF = only_dxf; + + std::cout << ".:Starting Bench Suite:." << std::endl; + + htmlout<<"Dxf file is : "<< Dxffile << std::endl; + + htmlout<<""<" + <" + <"<"; + texout<<" "; + } + + void close_cell(){ + htmlout <<""; + texout <<" "; + } + void open_row(){ + htmlout <<""; + texout <<""; + } + + void close_row(){ + htmlout <<""<< std::endl; + texout <<"\\\\ \\hline"<< std::endl; + } + + + void empty_cell(){ + this->open_cell(); + htmlout << "
Kernelgrid I(400 Circle_2)grid II(800 Circle_2)random double (100 Circle) rotation (125 Circle_2)
KernelDxf input is: "<< Dxffile <<"
" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter
" + <<"-"<<"" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "
" ; + texout<<"& -& -&-& -"; + this->close_cell(); + } + + void start(void){ + getrusage(RUSAGE_SELF,&before); + } + + void stop(void){ + getrusage(RUSAGE_SELF,&after); + } + + void summarize(int vertices,int hedges){ + int temp; +// temp=CGAL::Interval_nt<>::number_of_failures(); + numof_f_fails = temp - numof_f_fails; + std::cout << " numbers_of_filter_fails : " << numof_f_fails << std::endl; + + timersub(&(after.ru_utime),&(before.ru_utime),&utime); + timersub(&(after.ru_stime),&(before.ru_stime),&stime); + + htmlout << "" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter
" + <" + << numof_f_fails << "" + << vertices << "" + << hedges<<"" + << MemBefore << "" + << MemAfter<< "
"; + + texout << " & " <::number_of_failures(); + } + + void fail(void){ + htmlout << ""<" + << "
User timeNum. of failsverticeshalfedgesMemBeforeMemAfter" + <<"fail"<<"" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "
" ; + texout << "& fail & fail & fail & fail"; + std::cout << " :: Abort:: "<< std::endl; + } + + + template + void arrangement(const ArcContainer & ac){ + bool fail=false; + typedef typename CGAL::Arrangement_2 Pmwx; + typedef typename CGAL::Arr_naive_point_location Point_location; + + std::cout << "memory size before construction" << mem_sizer.virtual_size() << std::endl; + std::cout << "memory resident size before insert()" << mem_sizer.resident_size () << std::endl; + MemBefore = mem_sizer.virtual_size ()/1000000; + Pmwx _pm; + Point_location _pl(_pm); + try{ + this->start(); + insert(_pm,ac.begin(),ac.end(),boost::false_type()); + this->stop(); + } catch (std::exception &e) { + this->fail(); + std::cout << "Exception:" << std::endl << e.what() << std::endl; + fail=true; + } catch(...) { + this->fail(); + fail=true; + } + vert[i]=(int)_pm.number_of_vertices(); + hedg[i]=(int)_pm.number_of_halfedges(); + + if (!fail){this->summarize(_pm.number_of_vertices(),_pm.number_of_halfedges());} + + + MemAfter = mem_sizer.virtual_size ()/1000000; + std::cout << "memory size after insert()" << mem_sizer.virtual_size () << std::endl; + std::cout << "memory resident size after insert()" << mem_sizer.resident_size () << std::endl; + _pm.clear(); + } + + + +template + void grid(){ + i=1; + ArcContainer ac; + _bench_input_grid(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + + template + void grid2(){ + i=2; + ArcContainer ac; + _bench_input_grid2(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + + template + void random(){ + i=3; + ArcContainer ac; + if (firsttime){ + _bench_input_random(ac); + std::cout << "Input from random generator!"<(ac); + std::cout << "Input from file!"<open_cell(); + this->arrangement(ac); + this->close_cell(); + firsttime = false; + } + + template + void dfx(const char* Dfxfile){ + i=4; + + ArcContainer arc; + _bench_input_dfx(arc,Dfxfile); + this->open_cell(); + this->arrangement(arc); + this->close_cell(); + } + + template + void rotation(){ + i=5; + bool fail=false; + ArcContainer arc; + try{ + _bench_input_rotation(arc); + } + catch (...) + { + this->fail(); + fail=true; + std::cout << "failed before input"; + } + + if (!fail){ + this->open_cell(); + this->arrangement(arc); + this->close_cell(); + this->close_row(); + } + } +public: + template + void Compute(const char* dxffile){ + if(!ONLY_DXF){ + this->grid(); + this->grid2(); + this->random(); + this->dfx(dxffile); + this->rotation(); + } + else{ + this->dfx(dxffile); + this->close_row(); + } + } + + template + void Compute_no_dxf(){ + if(!ONLY_DXF){ + this->grid(); + this->grid2(); + this->random(); + //this->empty_cell(); + this->rotation(); + } + } + + void empty_row(){ + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->close_row(); + } + +template + void Compute_dxf(const char* dxffile){ + this->dfx(dxffile); + this->close_row(); + } + + void kernel(const char* kernel){ + this->open_row(); + this->open_cell(); + htmlout << kernel; + texout << kernel ; + this->close_cell(); + } + + + void newDxfFilename(const char* Dxffilename=""){ + const char* newDxf = Dxffilename; + + if(!ONLY_DXF){ + htmlout<< "Kernelgrid Igrid IIrandom doubleDxf input is: "<< newDxf <<" rotation " + <KernelDxf input is: "<< newDxf <<" " + < +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +// CIRCULAR KERNEL TYPEDEFS +//typedef CGAL::MP_Float RT; +//typedef CGAL::Quotient NT1; +typedef CGAL::Gmpz RT; +typedef CGAL::Gmpq NT1; +typedef CGAL::Cartesian Linear_k1; +typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; +typedef CGAL::Circular_kernel_2 CircularKernel; +typedef CGAL::Arr_circular_arc_traits_2 CircularK_CA_Traits; +typedef CircularKernel::Circular_arc_2 CircularKArc; +typedef std::vector CircularKArcContainer; +typedef CircularKernel::Circular_arc_2 Circular_arc_2; +typedef CircularKernel::Line_arc_2 Line_arc_2; +typedef CGAL::Arr_circular_line_arc_traits_2 CircularK_Variant_Traits; +typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; +typedef std::vector CircularKVarArcContainer; + +// LAZY KERNEL TYPEDEFS +typedef CGAL::Interval_nt_advanced NT3; +typedef CGAL::Cartesian Linear_k3; +typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k3; +typedef CGAL::Circular_kernel_2 CK3_; +typedef CGAL::Lazy_circular_kernel_2 LazyCurvedK; +typedef CGAL::Arr_circular_arc_traits_2 LazyCurvedK_CA_Traits; +typedef LazyCurvedK::Circular_arc_2 LazyArc; +typedef std::vector LazyArcContainer; +typedef LazyCurvedK::Circular_arc_2 Circular_arc_3; +typedef LazyCurvedK::Line_arc_2 Line_arc_3; +typedef boost::variant LazyVarArc; +typedef std::vector LazyVarContainer; +//~ typedef CGAL::Arr_circular_line_arc_traits_2 LazyCurvedK_Variant_Traits; +typedef CGAL::Arr_circular_line_arc_traits_2 LazyCurvedK_Variant_Traits; + +// BBOX TYPEDEFS +typedef CGAL::Filtered_bbox_circular_kernel_2 + BBCircularKernel ; +typedef CGAL::Arr_circular_arc_traits_2 + BBCircularKernel_CA_Traits; +typedef BBCircularKernel::Circular_arc_2 + BBCircularKernelArc; +typedef std::vector + BBCircularKernelArcContainer; +typedef BBCircularKernel::Circular_arc_2 + Circular_arc_6; +typedef BBCircularKernel::Line_arc_2 + Line_arc_6; +typedef boost::variant + BBCircVarArc; +typedef std::vector + BBCircVarContainer; +typedef CGAL::Arr_circular_line_arc_traits_2 BBCircVariantTraits; + +// BBOX(LAZY) +typedef CGAL::Filtered_bbox_circular_kernel_2 + BBLazyKernel ; +typedef CGAL::Arr_circular_arc_traits_2 + BBLazyKernel_CA_Traits; +typedef BBLazyKernel::Circular_arc_2 + BBLazyKernelArc; +typedef std::vector + BBLazyKernelArcContainer; +typedef BBLazyKernel::Circular_arc_2 + Circular_arc_lazybb; +typedef BBLazyKernel::Line_arc_2 + Line_arc_lazybb; +typedef boost::variant + BBLazyVarArc; +typedef std::vector + BBLazyVarContainer; +typedef CGAL::Arr_circular_line_arc_traits_2 BBLazyVariantTraits; + +template +void do_main(const char *s) { + + // TYPEDEFS + typedef typename CK::Circular_arc_2 C2; + typedef typename CK::Line_arc_2 L2; + typedef typename CGAL::Arrangement_2 Pmwx; + typedef typename CGAL::Arr_naive_point_location Point_location; + + // LOADING CURVES + ArcContainer ac; + std::ifstream fin; + fin.open (s); + CGAL::variant_load( + fin, std::back_inserter(ac)); + fin.close(); + + std::cout << "Size:" << ac.size() << std::endl; + + // BENCHMARKING + Pmwx _pm; + Point_location _pl(_pm); + struct rusage before, after; + struct timeval utime, stime; + getrusage(RUSAGE_SELF,&before); + insert(_pm,ac.begin(),ac.end(),boost::false_type()); + getrusage(RUSAGE_SELF,&after); + timersub(&(after.ru_utime),&(before.ru_utime),&utime); + timersub(&(after.ru_stime),&(before.ru_stime),&stime); + std::cout<<"Time="<< utime.tv_sec<<"."<< std::setw(6) << + std::setfill('0')<< utime.tv_usec <= 0 && j < 9)) { + if(i == 1) do_main(dxf_filename[j]); + if(i == 2) do_main(dxf_filename[j]); + if(i == 3) do_main(dxf_filename[j]); + if(i == 4) do_main(dxf_filename[j]); + if((i >= 5) || (i <= 0)) std::cout << "INVALID PARAMETERS" << std::endl; + } else { + int k = -1; + if(j == 9) k = 0; + if(j == ('a'-'0')) k = 1; + if(j == ('b'-'0')) k = 2; + if(j == ('c'-'0')) k = 3; + if(j == ('d'-'0')) k = 4; + if(i == 1) do_main(k); + if(i == 2) do_main(k); + if(i == 3) do_main(k); + if(i == 4) do_main(k); + if(i == 5) do_main(k); + if(i == 6) do_main(k); + if(i == 7) do_main(k); + if(i == 8) do_main(k); + } + } else std::cout << "INVALID PARAMETERS" << std::endl; + + return 0; +} diff --git a/Circular_kernel_2/benchmark/benchmarks_arrangement.cpp b/Circular_kernel_2/benchmark/benchmarks_arrangement.cpp new file mode 100644 index 00000000000..8cd6298208e --- /dev/null +++ b/Circular_kernel_2/benchmark/benchmarks_arrangement.cpp @@ -0,0 +1,437 @@ +#define CGAL_CAST_INT +#define CIRCULAR_KERNEL_2 +#define LAZY_CURVED_KERNEL_2 +#define CIRCULAR_KERNEL_2_FILTERED_HEXAGON +#define LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON +#define CIRCULAR_KERNEL_2_FILTERED_BBOX +#define LAZY_CURVED_KERNEL_2_FILTERED_BBOX + + +#include +#include +#include + +#include + +#include + +#include + +#include +#include +//#include + +#include + +#ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON +#include +#endif + +#include + +#include +#include +#include + + +#include +#include + +#include "benchmark.h" + +int main(int argc, char* argv[]) +{ //char* Dxffilename[]={"myFirst.dxf","cad_l1.dxf"}; + const char* Dxffilename[]={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","mask1.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","cad_l2.dxf","cad_l1.dxf","CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"}; + std::string Htmlfilename; + std::string Texfilename; + char exten[4]; + int i; + i=0; + + +if (argv[1] != NULL) + { + int len =strlen(argv[1]); + for (int j=0; j < 3 ; j++) + { + exten[j]=argv[1][len - 3 + j]; + } + if (strncmp(exten,"dxf",3) !=0) + { + std::cout<< "File is not correct (*.dxf is needed)." << std::endl; + return 0; + } + else{ + Dxffilename[i] = argv[1]; + std::cout<< "File "<< Dxffilename[i] << " is correct."<2 and argv[2] != NULL) + { + int len =strlen(argv[2]); + for (int j=0; j < 4 ; j++) + { + exten[j]=argv[2][len - 4 + j]; + } + if (strncmp(exten,"html",4) !=0) + { + std::cout<< "File "<< argv[2] << " is not correct (*.html is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[2] << " is correct." < NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CircularKernel; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 CircularK_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0; +// typedef CGAL::Circular_arc_traits_tracer CircularK_CA_Traits; +// #endif + + typedef CircularKernel::Circular_arc_2 CircularKArc; + typedef std::vector CircularKArcContainer; + bench.kernel("CkCircArc"); + + bench.Compute_no_dxf(); + + + typedef CircularKernel::Circular_arc_2 Circular_arc_2; + typedef CircularKernel::Line_arc_2 Line_arc_2; + typedef CGAL::Arr_circular_line_arc_traits_2 CircularK_Variant_Traits; + + typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; + typedef std::vector CircularKVarArcContainer; + + bench.kernel("CKVar"); + + //bench.Compute(Dxffilename[i]); + +//bench.Compute_dxf(Dxffilename[i]); +bench.Compute_no_dxf(); + + #endif +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2 + + typedef CGAL::Quotient NT2; + typedef CGAL::Cartesian Linear_k2; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k2; + typedef CGAL::Circular_kernel_2 CK2_; + + + typedef CGAL::Interval_nt_advanced NT3; + typedef CGAL::Cartesian Linear_k3; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k3; + typedef CGAL::Circular_kernel_2 CK3_; + + + typedef CGAL::Lazy_circular_kernel_2 LazyCurvedK; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 LazyCurvedK_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_2; +// typedef CGAL::Circular_arc_traits_tracer LazyCurved_kTraits; +// #endif + + typedef LazyCurvedK::Circular_arc_2 LazyArc; + typedef std::vector LazyArcContainer; + + bench.kernel("LazyCircArc") ; + + bench.Compute_no_dxf(); + + + typedef LazyCurvedK::Circular_arc_2 Circular_arc_3; + typedef LazyCurvedK::Line_arc_2 Line_arc_3; + typedef boost::variant LazyVarArc; + typedef std::vector LazyVarContainer; + typedef CGAL::Arr_circular_line_arc_traits_2 LazyCurvedK_Variant_Traits; + + bench.kernel("LazyKVar"); + + //bench.Compute(Dxffilename[i]); + //bench.Compute_dxf(Dxffilename[i]); + bench.Compute_no_dxf(); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef CIRCULAR_KERNEL_2_FILTERED_HEXAGON + + typedef CGAL::Filtered_hexagon_circular_kernel_2 CircularKernelHexagon; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 CircularKernHex_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_3; +// typedef CGAL::Circular_arc_traits_tracer CircularKernHex_CA_Traits; +// #endif + + typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc; + typedef std::vector CircularKernHexArcContainer; + bench.kernel("CK Hex CircArcTraits"); + + bench.Compute_no_dxf(); + + + typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4; + typedef CircularKernelHexagon::Line_arc_2 Line_arc_4; + typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc; + typedef std::vector CircularKernHexVarArcContainer; + typedef CGAL::Arr_circular_line_arc_traits_2 CircularKernHex_Variant_Traits; + + bench.kernel("CK Hex VarTraits"); + + // bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2_FILTERED_HEXAGON + + + typedef CGAL::Filtered_hexagon_circular_kernel_2 LazyKernelHexagon; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 LazyKernelHexagon_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_4; +// typedef CGAL::Circular_arc_traits_tracer LazyKernelHexagon_CA_Traits; +// #endif + + typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc; + typedef std::vector LazyKernelHexagonArcContainer; + bench.kernel("LazyK Hex CircArcTraits"); + + bench.Compute_no_dxf(); + + typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5; + typedef LazyKernelHexagon::Line_arc_2 Line_arc_5; + typedef boost::variant HxLazyVarArc; + typedef std::vector HxLazyVarContainer; + typedef CGAL::Arr_circular_line_arc_traits_2 HxLazyVariantTraits; + + bench.kernel("LazyK Hex VarTraits") ; + + //bench.Compute(Dxffilename[i]); +bench.Compute_no_dxf(); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef CIRCULAR_KERNEL_2_FILTERED_BBOX + + typedef CGAL::Filtered_bbox_circular_kernel_2 BBCircularKernel ; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 BBCircularKernel_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_5; +// typedef CGAL::Circular_arc_traits_tracer BBCircularKernel_CA_Traits; +// #endif + typedef BBCircularKernel::Circular_arc_2 BBCircularKernelArc; + typedef std::vector BBCircularKernelArcContainer; + bench.kernel("CK BBox CircArcTraits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernel::Circular_arc_2 Circular_arc_6; + typedef BBCircularKernel::Line_arc_2 Line_arc_6; + typedef boost::variant BBCircVarArc; + typedef std::vector BBCircVarContainer; + typedef CGAL::Arr_circular_line_arc_traits_2 BBCircVariantTraits; + + bench.kernel("CK BBox VarTraits") ; + + // bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + #ifdef LAZY_CURVED_KERNEL_2_FILTERED_BBOX + + typedef CGAL::Filtered_bbox_circular_kernel_2 BBLazyCurvedK; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Arr_circular_arc_traits_2 BBLazyCurvedK_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_6; +// typedef CGAL::Circular_arc_traits_tracer BBLazyCurvedK_CA_Traits; +// #endif + + typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc; + typedef std::vector BBLazyCurvedKArcContainer; + bench.kernel("LLazyK BBox CircArcTraits"); + + bench.Compute_no_dxf(); + + + typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7; + typedef BBLazyCurvedK::Line_arc_2 Line_arc_7; + typedef boost::variant BBLazyVarArc; + typedef std::vector< BBLazyVarArc> BBLazyVarContainer; + typedef CGAL::Arr_circular_line_arc_traits_2 BBLazyVariantTraits; + + bench.kernel("LLazyK BBox VarTraits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf(); + + #endif + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircKHexagon ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircKHexagonCATraits; + #else + typedef CGAL::Circular_arc_traits Traits0_7; + typedef CGAL::Circular_arc_traits_tracer BBCircKHexagonCATraits; + #endif + typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc; + typedef std::vector BBCircKHexagonArcCont; + bench.kernel("BBox Circular kernel filtered Hexagon CircArcTraits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8; + typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8; + typedef boost::variant BBCircularKernelHexagonVarArc; + typedef std::vector BBCircularKernelHexagonVarContainer; + typedef CGAL::Variant_traits BBCircularKernelHexagonVariantTraits; + + bench.kernel("BBox Circular kernel filtered Hexagon VarTraits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf();*/ + /*-------------------------------------------------------------------------------------------------------------------------- + -----------------------------------------------------------------------------------------------------------------------------*/ +// if (i+1<2) +// { +// try{ +// if (strcmp(Dxffilename[i+1],"")) +// { +// try{ +// fin.open (Dxffilename[i]); +// } +// catch(...){ +// std::cout<<"error"< +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + + +#include "IntStr.h" +#include "benchmark_parser.h" +#include +#include +template +struct Breader : public Benchmark_visitor { + typedef typename CGAL::Quotient NT1; + typedef typename K::Point_2 Point_2; + typedef typename K::Circle_2 Circle_2; + typedef std::list Circles; + typedef std::list Points; + typedef std::list Numbers; + typedef std::list > Polygon; + typedef std::list Polygons; + Points points; + Numbers numbers; + Circles circles; + Polygons polygons; + int x_; + int y_; + Breader() {} + virtual void token_not_handled( std::string s) {} + virtual void accept_benchmark_name( std::string s) { + Benchmark_visitor::accept_benchmark_name(s); + std::cerr << "name '" << s << "', "; + } + + virtual void accept_classification( std::string problem, + std::string geom, + std::string clas, + std::string family, + std::string instance, + std::string release) { + + if ((problem != "Arrangement") && (problem != "CSG") + && (problem != " ")) + error_handler + ( "classification error"); + + if ((geom != "Lines") && (geom != "Circles") && (geom != "Conics") + && (geom != "Cubics") && (geom != "Quartics") + && (geom != "ArbitraryDegreeCurves") && ( geom != "Quadrics") + && (geom != "Tori") && (geom != "Planes") && (geom != " ")) + error_handler ( "classification error" ); + + if ((clas != "FullCurves") && (clas != "Ellipses") + && (clas != "BoundedArcs") && (clas != "UnboundedArcs") + && (clas != "FullSurfaces") && (clas != "BoundedPatches") + && (clas != "UnboundedPatches") && (clas != " ")) + error_handler ( "classification error" ); + } + virtual void begin_circle_2() { + + std::cerr << "circle begin" << std::endl; + x_=0; + y_=0; + } + + virtual void end_circle_2() { + + std::cerr << "circle end" << std::endl; + //Circle_2 cyrc = typename K::Construct_circle_2()(Point_2(x_,y_), integer*integer); + NT1 r= numbers.back(); + Circle_2 circ = typename K::Construct_circle_2()(points.back(), r*r); + circles.push_back(circ); + } + + virtual void accept_point_2( std::string x, std::string y) { + + std::cerr << "accept_point_2 :"< NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CK; + typedef CK::Circular_arc_2 Circular_arc_2; + typedef CK::Line_arc_2 Line_arc_2; + typedef CGAL::Variant_traits CircularK_Variant_Traits; + typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; + typedef std::vector CircularKVarArcContainer; + CircularKVarArcContainer arc; + typedef CGAL::Arrangement_2 Pmwx; + typedef CGAL::Arr_naive_point_location Point_location; + Pmwx _pm; + Point_location _pl(_pm); + typedef CK::Circle_2 Circle_2; + typedef std::list Circles; + +int exit_status = 0; + if ( argc < 2) { + return 0; + } else { + for ( int i = 1; i < argc; ++i) { + Breader check; + std::cerr << "File '" << argv[i] << "', "< +#include "dxf_converter.h" + +int main(int argc, char* argv[]){ + +Dxf_converter converter; +char* Benchfilename; +char exten[4]; + + +if (argv[1] != NULL) + { + int len =strlen(argv[1]); + for (int j=0; j < 3 ; j++) + { + exten[j]=argv[1][len - 3 + j]; + } + if (strncmp(exten,"dxf",3)) + { + std::cout<< "File is not correct (*.dxf is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[1] << " is correct."<2 and argv[2] != NULL) + { + int len =strlen(argv[2]); + for (int j=0; j < 4 ; j++) + { + exten[j]=argv[2][len - 4 + j]; + } + if (strncmp(exten,"arr",4) !=0) + { + std::cout<< "File "<< argv[2] << " is not correct (*.arr is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[2] << " is correct." < +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +using namespace std; +class Dxf_converter { + //typedef std::pair Point_2; +/* + typedef CGAL::Quotient NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_2_2 Algebraic_k1; + typedef CGAL::Curved_kernel CircularKernel;*/ +// typedef double type; +// typedef CGAL::Cartesian NT1; +//typedef CGAL::Quotient NT1; +typedef CGAL::Gmpq NT1; +// typedef CGAL::Quotient NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CK; + typedef CK::Circular_arc_point_2 Circular_arc_point_2; + typedef CK::Line_2 Line_2; + typedef CK::Point_2 Point_2; + typedef CK::Circle_2 Circle_2; + typedef std::list > Polygon; + typedef std::list Polygons; + typedef CK::Intersect_2 Intersect_2; + typedef CK::FT FT; +private: + + void + header(std::istream& is) + { + int n; + double xmin, ymin; + double xmax, ymax; + is >> n; + assert(n == 9); + char c; + is >> c; + assert(c == '$'); + std::string str; + is >> str; + if(str == std::string("EXTMIN")){ + is >> n; + assert(n == 10); + is >> xmin; + is >> n; + assert(n == 20); + is >> ymin; + } + is >> n; + assert(n == 9); + is >> c; + assert(c == '$'); + is >> str; + if(str == "EXTMAX"){ + is >> n; + assert(n == 10); + is >> xmax; + is >> n; + assert(n == 20); + is >> ymax; + } + } + + + void + skip_header(std::istream& is) + { + int n; + is >> n; + assert(n == 0); + std::string str; + is >> str; + assert(str == "SECTION"); + is >> n; + assert(n == 2); + is >> str; + if(str == "HEADER"){ + header(is); + } + is >> n; + assert(n == 0); + is >> str; + assert(str == "ENDSEC"); + } + + + + void + read_circle(std::istream& is,std::ostream& os) + { + int n; + double cx, cy, r; + std::string str; + is >> n; + assert(n == 8); + is >> n; + assert(n == 0); + + is >> n; + assert(n == 10); + is >> cx; + is >> n; + assert(n == 20); + is >> cy; + is >> n; + assert(n == 40); + is >> r; + NT1 x(cx),y(cy),gr(r); + os<<"Circle_2 ("<<"Point_2("<<"Rational(" <begin(); + first_point = pit->first; + while(true){ + ps = pit->first; + bulge = pit->second; + pit++; + if(pit ==it->end()){ + break; + } + pt = pit->first; + if(bulge == FT(0)){ + if(ps != pt){ + os<<"Line_arc_2("<<"Point_2("<<"Rational(" <> n; + if(n != 0){ + int m; + is >> m; + } + } while(n != 0); + + do { + is >> str; + if(str == "VERTEX"){ + is >> n; + assert(n == 8); + is >> n; + assert(n == 0); + is >> n; + assert(n == 10); + is >> x; + is >> n; + assert(n == 20); + is >> y; + is >> n; + len = 0; + if(n == 42){ + is >> len; + } else { + assert(n == 0); + } + //std::cout<<"Polygon"<> n; + assert(n == 8); + is >> n; + assert(n == 0); + std::cout<> n; + assert(n == 0); + is >> str; + assert(str == "SECTION"); + is >> n; + is >> str; + assert(str == "ENTITIES"); + do { + is >> n; + assert(n == 0); + is >> str; + if(str == "POLYLINE"){ + Polygon p; + poly.push_back(p); + std::cout<< "it's polyline" <> n; + assert(n == 0); + is >> str; + assert(str == "EOF"); + std::cout << "read_entities - finished"< +#include + +template +void _bench_input_dfx(ArcContainer& arcs,char* Dfxfile){ +std::ifstream fin; +fin.open (Dfxfile); + typedef typename CK::Circular_arc_2 Circular_arc_2; + typedef typename CK::Line_arc_2 Line_arc_2; +CGAL::variant_load(fin, std::back_inserter(arcs)); +fin.close(); +} + +template +void _bench_input_grid(ArcContainer& ac){ + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + int x = 5; + int y = 5; + int r = 5; + for(int i = 0; i < 20; i++){ + for(int j = 0; j <20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } +// CGAL::Random theRandom(77147); +// double random_max = 15; +// double random_min = -16; +// for(int i = 0; i < 100 ; i++){ +// double x1, y1, x2, y2 = 0.0; +// do{ +// x1 = theRandom.get_double(random_min,random_max); +// y1 = theRandom.get_double(random_min,random_max); +// x2 = theRandom.get_double(random_min,random_max); +// y2 = theRandom.get_double(random_min,random_max); +// }while ((x1 == x2) && (y1 == y2)); +// ac.push_back( Line_arc_2( Point_2(x1,y1), Point_2(x2, y2))); +// } +} + +template +void _bench_input_grid2(ArcContainer& ac) +{ + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + int x = 10; + int y = 10; + int r = 10; + + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back(Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } + + x += r; + y += r; + for(int i = 0; i < 20; i++){ + for(int j = 0; j < 20; j++){ + ac.push_back( Circle_2( Point_2(x + j*r, y + i*r), r*r)); + } + } +} + +template +void _bench_input_random(ArcContainter& arcs) +{ + std::ofstream fout("random.inp"); + + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + + CGAL::Random generatorOfgenerator; + int random_seed = generatorOfgenerator.get_int(0, 123456); + std::cout << "random_seed = " << random_seed << std::endl; + + CGAL::Random theRandom(random_seed); +// CGAL::Random theRandom(77147); + double random_max = 10; + double random_min = -10; + + for(int i = 0; i < 100 ; i++){ + double x = theRandom.get_double(random_min,random_max); + double y = theRandom.get_double(random_min,random_max); + double r = theRandom.get_double(0.1,random_max); + fout << x << " " << y << " " << r << " " ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + fout.close(); +// for(int i = 0; i < 20 ; i++){ +// double x1, y1, x2, y2 = 0.0; +// do{ +// x1 = theRandom.get_double(random_min,random_max); +// y1 = theRandom.get_double(random_min,random_max); +// x2 = theRandom.get_double(random_min,random_max); +// y2 = theRandom.get_double(random_min,random_max); +// }while ((x1 == x2) && (y1 == y2)); +// arcs.push_back( Line_arc_2( Point_2(x1,y1), Point_2(x2, y2))); +// } +// + std::cout << arcs.size() << std::endl; + +} +template +void _bench_input_file(ArcContainter& arcs) +{ double x,y, r; + typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + + std::ifstream fin("random.inp"); + for(int i = 0; i < 100 ; i++){ + // fin >> x >> y >> r ; + fin >> x >> y >> r ; + arcs.push_back( Circle_2( Point_2(x,y), r*r)); + } + fin.close(); +} + +template +void _bench_input_rotation(ArcContainter& ac) +{ +typedef typename CK::Point_2 Point_2; + typedef typename CK::Circle_2 Circle_2; + int x = 10; + int y = 10; + int r = 10; + int R =0; +for(int k = 0; k < 5; k++){ + for(int i = 0; i < 5; i++){ + for(int j = 0; j < 5; j++){ + R = (r+k)*(r+k); + ac.push_back( Circle_2( Point_2(x + i*r, y + j*r),R)); + } + } +} + +} + diff --git a/Circular_kernel_2/benchmark/incremental_insertion/benchmark.h b/Circular_kernel_2/benchmark/incremental_insertion/benchmark.h new file mode 100644 index 00000000000..2ab0bd868d0 --- /dev/null +++ b/Circular_kernel_2/benchmark/incremental_insertion/benchmark.h @@ -0,0 +1,382 @@ +#ifndef ECG_BENCH_H +#define ECG_BENCH_H + +#include +#include + +#include +#include +#include +#include +#include +#include +#include "Input_data.h" +#include + +class Bench +{ + int numof_f_fails; + std::ofstream htmlout,texout; + struct rusage before,after; + struct timeval utime,stime; + bool firsttime; + char *description; + int vert[4],hedg[4]; + int i; + CGAL::Memory_sizer mem_sizer; + char* Dxffile; + bool ONLY_DXF; + + + public: + + Bench( char *fhtml="benchmarks.html", char* ftex="benchmarks.tex",char* Dxffilename="",const bool only_dxf=false): + htmlout(fhtml,std::ios::app), + texout(ftex,std::ios::app) + { i=0; + numof_f_fails= 0; + Dxffile=Dxffilename; + ONLY_DXF = only_dxf; + + description = "Arrangement "; + + std::cout << ".:Starting Bench Suite:." << std::endl; + std::cout << "bencmarking : " << description << std::endl; + + htmlout<<"Dxf file is : "<< Dxffile << std::endl; + htmlout<<""<" + <" + <"<"; + texout<<" "; + } + void close_cell() + { + htmlout <<""; + texout <<" "; + } + void open_row() + { + htmlout <<""; + texout <<""; + } + void close_row() + { + htmlout <<""<< std::endl; + texout <<"\\\\ \\hline"<< std::endl; + } + + void kernel(char* kernel) + { this->open_row(); + this->open_cell(); + htmlout << kernel; + texout << kernel ; + this->close_cell(); + } + + void empty_cell() + { + this->open_cell(); + htmlout << "
Kernelgrid I(400 Circle_2)grid II(800 Circle_2)random double (100 Circle)Dxf input. Dxf file is : "<< Dxffile <<" rotation (125 Circle_2)
KernelDxf input. Dxf file is : "<< Dxffile <<"
" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedges
" + <<"-"<<"" + <<"-"<< "" + <<"-"<< "" + <<"-"<< "
" ; + texout<<"& -"; + this->close_cell(); + } + + void infotable(){ + + texout<< "\\hline\\hline & grid I&grid II &random double & Dxf input. Dxf file is : "<< Dxffile <<" & rotation \\\\ \\hline" << std::endl + << "vertices" ; + for (int k=1; k < 6 ;k++) + { + texout << " & "<< vert[k]; + } + texout<<"\\\\ \\hline"<Kernelgrid Igrid IIrandom doubleDxf input. Dxf file is : "<< Dxffile <<" rotation " + <KernelDxf input. Dxf file is : "<< Dxffile <<" " + <::number_of_failures(); + numof_f_fails = temp - numof_f_fails; + + std::cout << " numbers_of_filter_fails : " << numof_f_fails << std::endl; + timersub(&(after.ru_utime),&(before.ru_utime),&utime); + timersub(&(after.ru_stime),&(before.ru_stime),&stime); + + htmlout << "" << std::endl + << "" + << "
User timeNum. of failsverticeshalfedges
" + <" + << numof_f_fails << "" + << vertices << "" + << hedges<< "
"; + + texout << " & " <::number_of_failures(); + } + + void fail(void) + { + htmlout << "" <" + << "
User timeNum. of failsverticeshalfedges" + <<"fail"<<"" + <<"fail"<< "" + <<"fail"<< "" + <<"fail"<< "
" ; + texout << "&" <<"fail"; + std::cout << " :: Abort:: "<< std::endl; + } + + template + void arrangement(const ArcContainer & ac){ + bool fail=false; + typedef typename CGAL::Arrangement_2 Pmwx; + typedef typename CGAL::Arr_naive_point_location Point_location; + std::cout << "memory size before construction" << mem_sizer.virtual_size() << std::endl; + std::cout << "memory resident size before insert()" << mem_sizer.resident_size () << std::endl; + Pmwx _pm; + Point_location _pl(_pm); + + std::cout << "Construction complited"<start(); + for (typename ArcContainer::const_iterator it=ac.begin(); + it != ac.end(); ++it) { + insert(_pm,*it,_pl,boost::false_type()); + }; + this->stop(); + } + catch (...) { + this->fail(); + fail=true; + } + vert[i]=(int)_pm.number_of_vertices(); + hedg[i]=(int)_pm.number_of_halfedges(); + + + //_pl.~Point_location(); + // _pm.~Pmwx(); + if (!fail){this->summarize(_pm.number_of_vertices(),_pm.number_of_halfedges());} + + _pm.clear(); + std::cout << "memory size after insert()" << mem_sizer.virtual_size () << std::endl; + std::cout << "memory resident size after insert()" << mem_sizer.resident_size () << std::endl; + } + + + +template + void grid(){ + + i=1; + + ArcContainer ac; + + _bench_input_grid(ac); + + this->open_cell(); + + this->arrangement(ac); + + this->close_cell(); + } + + template + void grid2(){ + i=2; + + ArcContainer ac; + + _bench_input_grid2(ac); + this->open_cell(); + this->arrangement(ac); + this->close_cell(); + } + template + void random() + { + i=3; + + ArcContainer ac; + if (firsttime) + { + _bench_input_random(ac); + std::cout << "Input from random generator!"<(ac); + std::cout << "Input from file!"<open_cell(); + this->arrangement(ac); + this->close_cell(); + firsttime = false; + } + template + void dfx(char* Dfxfile){ + i=4; + + ArcContainer arc; + _bench_input_dfx(arc,Dfxfile); + this->open_cell(); + this->arrangement(arc); + + this->close_cell(); + + } + + template + void rotation(){ + i=5; + + ArcContainer arc; + try{ + + _bench_input_rotation(arc); + } + catch (...) + { + std::cout << "failed before input"; + } + this->open_cell(); + this->arrangement(arc); + + this->close_cell(); + + this->close_row(); + } + + template + void Compute(char* dxffile) + { +// this->grid(); +// +// this->grid2(); +// +// this->random(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + + this->dfx(dxffile); + +// this->rotation(); + this->empty_cell(); + this->close_row(); + + } + + template + void Compute_no_dxf() + { + this->grid(); + + + this->grid2(); + + this->random(); + this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->empty_cell(); +// this->close_row(); + this->rotation(); + } + + void empty_row() + { this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->empty_cell(); + this->close_row(); + + } + template + void Compute_dxf(char* dxffile) + { + this->dfx(dxffile); + this->close_row(); + } +}; + +#endif //#define ECG_BENCH_H + diff --git a/Circular_kernel_2/benchmark/incremental_insertion/benchmarks_arrangement.cpp b/Circular_kernel_2/benchmark/incremental_insertion/benchmarks_arrangement.cpp new file mode 100644 index 00000000000..c301da81847 --- /dev/null +++ b/Circular_kernel_2/benchmark/incremental_insertion/benchmarks_arrangement.cpp @@ -0,0 +1,391 @@ +#define CGAL_CAST_INT +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + +#include + +#include + +#include + +#include +#include +#include + + +#include +#include + +#include "benchmark.h" + +int main(int argc, char* argv[]) +{ + char* Dxffilename[]={"myFirst.dxf","minimask0.dxf","minimask1.dxf","mask0.dxf","smallpainttrack.dxf","mask0_25.dxf","mask0_5.dxf","mask1.dxf","cad_l2.dxf","cad_l1.dxf"/*,"CIOnZDraw.dxf","che_mod1.dxf","elekonta.dxf","painttrack.dxf","netlist_signal_1.dxf","51.dxf"*/}; + char* Htmlfilename; + char* Texfilename; + char exten[4]; + int i; + i=0; + + +if (argv[1] != NULL) + { + int len =strlen(argv[1]); + for (int j=0; j < 3 ; j++) + { + exten[j]=argv[1][len - 3 + j]; + } + if (strncmp(exten,"dxf",3) !=0) + { + std::cout<< "File is not correct (*.dxf is needed)." << std::endl; + return 0; + } + else{ + Dxffilename[i] = argv[1]; + std::cout<< "File "<< Dxffilename[i] << " is correct."<2 and argv[2] != NULL) + { + int len =strlen(argv[2]); + for (int j=0; j < 4 ; j++) + { + exten[j]=argv[2][len - 4 + j]; + } + if (strncmp(exten,"html",4) !=0) + { + std::cout<< "File "<< argv[2] << " is not correct (*.html is needed)." << std::endl; + return 0; + } + else{ + std::cout<< "File "<< argv[2] << " is correct." < NT1; + typedef CGAL::Cartesian Linear_k1; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k1; + typedef CGAL::Circular_kernel_2 CircularKernel; +/* + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits CircularK_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0; + typedef CGAL::Circular_arc_traits_tracer CircularK_CA_Traits; + #endif + + typedef CircularKernel::Circular_arc_2 CircularKArc; + typedef std::vector CircularKArcContainer; + bench.kernel("Circular kernel Circular arc traits"); + + bench.Compute_no_dxf();*/ + + + typedef CircularKernel::Circular_arc_2 Circular_arc_2; + typedef CircularKernel::Line_arc_2 Line_arc_2; + typedef CGAL::Variant_traits CircularK_Variant_Traits; + + typedef boost::variant< Circular_arc_2, Line_arc_2 > CircularKVarArc; + typedef std::vector CircularKVarArcContainer; + + bench.kernel("Circular kernel Variant traits"); + +// bench.Compute(Dxffilename[i]); + bench.Compute_dxf(Dxffilename[i]); + +/*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Lazy_curved_Kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + + typedef CGAL::Quotient NT2; + typedef CGAL::Cartesian Linear_k2; + typedef CGAL::Algebraic_kernel_for_circles_2_2 Algebraic_k2; + typedef CGAL::Circular_kernel_2 CK2_; + + //typedef CGAL::Interval_nt<> NT2; + typedef CGAL::Interval_nt_advanced NT3; + typedef CGAL::Cartesian Linear_k3; + typedef CGAL::Algebraic_kernel_2_2 Algebraic_k3; + typedef CGAL::Curved_kernel CK3_; + + + typedef CGAL::Lazy_circular_kernel_2 LazyCurvedK; + +// #ifndef CGAL_CURVED_KERNEL_DEBUG +// typedef CGAL::Circular_arc_traits LazyCurvedK_CA_Traits; +// #else +// typedef CGAL::Circular_arc_traits Traits0_2; +// typedef CGAL::Circular_arc_traits_tracer LazyCurved_kTraits; +// #endif +// +// typedef LazyCurvedK::Circular_arc_2 LazyArc; +// typedef std::vector LazyArcContainer; +// +// bench.kernel("Lazy curved kernel Circular arc traits") ; +// +// bench.Compute_no_dxf(); + + + typedef LazyCurvedK::Circular_arc_2 Circular_arc_3; + typedef LazyCurvedK::Line_arc_2 Line_arc_3; + typedef boost::variant LazyVarArc; + typedef std::vector LazyVarContainer; + typedef CGAL::Variant_traits LazyCurvedK_Variant_Traits; + + bench.kernel("Lazy curved kernel Variant traits"); + + // bench.Compute(Dxffilename[i]); + // bench.Compute_dxf(Dxffilename[i]); + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* +asdashhhhhhhhhhhhfhjhdghdf + typedef CGAL::Filtered_hexagon_curved_kernel CircularKernelHexagon; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits CircularKernHex_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_3; + typedef CGAL::Circular_arc_traits_tracer CircularKernHex_CA_Traits; + #endif + + typedef CircularKernelHexagon::Circular_arc_2 CircularKernHexArc; + typedef std::vector CircularKernHexArcContainer; + bench.kernel("Circular kernel filtered hexagon Circular arc traits"); + + bench.Compute_no_dxf(); + + + typedef CircularKernelHexagon::Circular_arc_2 Circular_arc_4; + typedef CircularKernelHexagon::Line_arc_2 Line_arc_4; + typedef boost::variant< Circular_arc_4, Line_arc_4 > CircularKernHexVarArc; + typedef std::vector CircularKernHexVarArcContainer; + typedef CGAL::Variant_traits CircularKernHex_Variant_Traits; + + bench.kernel("Circular kernel filtered hexagon Variants traits"); + + bench.Compute(Dxffilename[i]); + // bench.Compute_no_dxf(); + + + */ + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!Filtered_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_hexagon_curved_kernel LazyKernelHexagon; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits LazyKernelHexagon_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_4; + typedef CGAL::Circular_arc_traits_tracer LazyKernelHexagon_CA_Traits; + #endif + typedef LazyKernelHexagon::Circular_arc_2 LazyKernelHexagonArc; + typedef std::vector LazyKernelHexagonArcContainer; + bench.kernel("Lazy curved kernel filtered hexagon Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef LazyKernelHexagon::Circular_arc_2 Circular_arc_5; + typedef LazyKernelHexagon::Line_arc_2 Line_arc_5; + typedef boost::variant HxLazyVarArc; + typedef std::vector HxLazyVarContainer; + typedef CGAL::Variant_traits HxLazyVariantTraits; + + bench.kernel("Lazy curved kernel filtered hexagon Variants traits") ; + + bench.Compute(Dxffilename[i]); +//bench.Compute_no_dxf(); +*/ + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircularKernel ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircularKernel_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_5; + typedef CGAL::Circular_arc_traits_tracer BBCircularKernel_CA_Traits; + #endif + typedef BBCircularKernel::Circular_arc_2 BBCircularKernelArc; + typedef std::vector BBCircularKernelArcContainer; + bench.kernel("Circular kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernel::Circular_arc_2 Circular_arc_6; + typedef BBCircularKernel::Line_arc_2 Line_arc_6; + typedef boost::variant BBCircVarArc; + typedef std::vector BBCircVarContainer; + typedef CGAL::Variant_traits BBCircVariantTraits; + + bench.kernel("Circular kernel filtered bbox Variants traits") ; + + bench.Compute(Dxffilename[i]); + // bench.Compute_no_dxf(); + */ + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_hexagone_Lazy_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBLazyCurvedK; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBLazyCurvedK_CA_Traits; + #else + typedef CGAL::Circular_arc_traits Traits0_6; + typedef CGAL::Circular_arc_traits_tracer BBLazyCurvedK_CA_Traits; + #endif + typedef BBLazyCurvedK::Circular_arc_2 BBLazyCurvedKArc; + typedef std::vector BBLazyCurvedKArcContainer; + bench.kernel("Lazy curved kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + + typedef BBLazyCurvedK::Circular_arc_2 Circular_arc_7; + typedef BBLazyCurvedK::Line_arc_2 Line_arc_7; + typedef boost::variant BBLazyVarArc; + typedef std::vector< BBLazyVarArc> BBLazyVarContainer; + typedef CGAL::Variant_traits BBLazyVariantTraits; + + bench.kernel("Lazy curved kernel filtered bbox Variants traits") ; + + bench.Compute(Dxffilename[i]); + //bench.Compute_no_dxf(); + */ + /*------------------------------------------------------------------------------------------------------------------------- + !!!!!!!!!!!bbox_filtered_Filtered_hexagone_Circular_kernel!!!!!!!!!!!!!!!!!! + + -------------------------------------------------------------------------------------------------------------------------*/ + /* + typedef CGAL::Filtered_bbox_curved_kernel BBCircKHexagon ; + + #ifndef CGAL_CURVED_KERNEL_DEBUG + typedef CGAL::Circular_arc_traits BBCircKHexagonCATraits; + #else + typedef CGAL::Circular_arc_traits Traits0_7; + typedef CGAL::Circular_arc_traits_tracer BBCircKHexagonCATraits; + #endif + typedef BBCircKHexagon::Circular_arc_2 BBCircKHexagonArc; + typedef std::vector BBCircKHexagonArcCont; + bench.kernel("BBox Circular kernel filtered bbox Circular arc traits"); + + bench.Compute_no_dxf(); + + typedef BBCircularKernelHexagon::Circular_arc_2 Circular_arc_8; + typedef BBCircularKernelHexagon::Line_arc_2 Line_arc_8; + typedef boost::variant BBCircularKernelHexagonVarArc; + typedef std::vector BBCircularKernelHexagonVarContainer; + typedef CGAL::Variant_traits BBCircularKernelHexagonVariantTraits; + + bench.kernel("BBox Circular kernel filtered bbox Variants traits") ; + + //bench.Compute(Dxffilename[i]); + bench.Compute_no_dxf();*/ + /*-------------------------------------------------------------------------------------------------------------------------- + -----------------------------------------------------------------------------------------------------------------------------*/ + if (i+1<15) + { + if (strcmp(Dxffilename[i+1],"")) + { + bench.newDxfFilename(Dxffilename[i+1]); + } + else + { + std::cout << "that's all" << Dxffilename[i+1] << std::endl; + break; + } + } + } + +bench.infotable(); + + return 0; +} + diff --git a/Circular_kernel_2/benchmark/parser/Report.pdf b/Circular_kernel_2/benchmark/parser/Report.pdf new file mode 100644 index 00000000000..74f73816ebc Binary files /dev/null and b/Circular_kernel_2/benchmark/parser/Report.pdf differ diff --git a/Circular_kernel_2/benchmark/parser/Report.tex b/Circular_kernel_2/benchmark/parser/Report.tex new file mode 100644 index 00000000000..b38617d1cb6 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/Report.tex @@ -0,0 +1,215 @@ +\documentclass[10pt]{article} +\usepackage{amsmath} + + +\begin{document} +\section{Inroduction} + [ ... ] +\section{Objects types for Extension of Parser} + + We describe objects which we want to put in an extended version of Benchmark file format in the following table. The first column lists the nonterminal symbol. The second column lists grammar rules where several alternative choices are listed below each other. The third column gives a description of the object. + +\begin{tabular}{|c|c|c|} \hline Type & syntax & description \\ \hline +\hline\hline +Circle\_2 & Circle\_2 (Point\_2,Rational) & Squered radius can be rational\\ +\hline +CircularPoint\_2 & CircularPoint\_2(Point\_2) &\\ + & CircularPoint\_2(AlgebraicReal,&\\ + & AlgebraicReal) &\\ +\hline + CircularArc\_2 & CircularArc\_2(Circle\_2) & Constructs an arc from a full circle. \\ + &CircularArc\_2(Circle\_2, &Circular\_arc\_2(Circle\_2 c,\\ + &CircularPoint\_2, &CircularPoint p1, \\ + &CircularPoint\_2) &CircularPoint p2);Constructthe\\ + & &linesegment supported by c, thatis \\ + & &oriented counterclockwise, whose \\ + & &source is p1 and whose target is p2.\\ + & &Precondition: p1 and p2 lie on c.\\ + &CircularArc\_2(Point\_2, &Circular\_arc\_2(begin, end, bulge).\\ + &Point\_2, &\\ + &Rational) &\\ +\hline + LineArc\_2 & LineArc\_2(LineSegment) &\\ + & LineArc\_2(CircularPoint, &\\ + & CircularPoint) &\\ + & LineArc\_2(Point\_2, &\\ + & Point\_2), &\\ + +\hline +\end{tabular} + +\section{Extention of the Parser} + In following we describe necessary changes to add our new tokens and rules to the parser. First, we describe new Benchmark Visitor functions. Second, we explain how to make changes in Parser source to make possible parsing our new objects. +\subsection{New Benchmark Visitors functions} + +In the following table are listed functions that do not exist in the Benchmark\_visitor class and must be added . The statements in curly braces \{...\} are function calls to the visitor. There are always a pair of functions that enclose the parsing parameters. +\\ +\begin{tabular}{|c|c|} \hline Object & grammar rule with visitor function \\ \hline +\hline\hline +Circle\_2 &Circle\_2\{begin\_circle\_2();\}\\ + &(Point\_2,Rational)\\ + &\{end\_circle\_2();\}\\ +\hline +CircularPoint\_2 &CircularPoint\_2\{begin\_CircularPoint\_2();\}\\ + &(Point\_2)\\ + &\{end\_circular\_CircularPoint\_2();\}\\ + &CircularPoint\_2\{begin\_CircularPoint\_2();\}\\ + &(AlgebraicReal,AlgebraicReal)\\ + &\{end\_circular\_CircularPoint\_2();\}\\ + +\hline + + CircularArc\_2 & CircularArc\_2 \{begin\_CircularArc\_2();\}\\ + &(Circle\_2)\\ + &\{end\_CircularArc\_2();\}\\ + & CircularArc\_2 \{begin\_CircularArc\_2();\}\\ + &(Circle\_2,CircularPoint\_2,CircularPoint\_2)\\ + &\{end\_CircularArc\_2();\}\\ + & CircularArc\_2\{begin\_CircularArc\_2();\}\\ + &(Point\_2,Point\_2,Rational)\\ + &\{end\_CircularArc\_2();\}\\ + +\hline + +LineArc\_2 &LineArc\_2\{begin\_LineArc\_2();\}\\ + &(LineSegment)\\ + &\{end\_LineArc\_2();\}\\\ + &LineArc\_2\{begin\_LineArc\_2();\}\\ + &(CircularPoint\_2,CircularPoint\_2)\\ + &\{end\_LineArc\_2();\}\\ + &LineArc\_2\{begin\_LineArc\_2();\}\\ + &(Point\_2,Point\_2)\\ + &\{end\_LineArc\_2();\}\\ + \hline +\end{tabular} + +\subsection{Extending of Parser by new types} +Here we describe how to add new tokens and rules to the parser. +\subsubsection{Extend the Scanner in benchmark\_lexer.l} +First thing that is needed to extend parser is to put new tokens in section with Token in coments. It is looks like this: + +\begin{verbatim} + /* Tokens */ + /* --------- */ +"FileFormat" { return FileFormat;} +"BenchmarkName" { return BenchmarkName; } +....... +\end{verbatim} + +In the end of this section add these lines: + +\begin{verbatim} +"CircularArc_2" { return CircularArc_2;} +"LineArc_2" { return LineArc_2;} +"CircularPoint_2" {return CircularPoint_2;} +\end{verbatim} + +The left string is representation in file format, the right word is its indentifier in the program code. +\subsubsection{Extended the Parser in benchmark\_parser.y} + In a section with words Structure tokens in coments, which looks like this: + +\begin{verbatim} +/* Structure tokens */ +/* ---------------- */ +%token FileFormat +%token BenchmarkName +%token Classification +.... +\end{verbatim} + add anywhere new lines with new tokens: +\begin{verbatim} +%token CircularArc_2 +%token LineArc_2 +%token CircularPoint_2 + +\end{verbatim} + +Now go to Grammar section and add new rules. In the and of stmt block add new lines with rules: + +\begin{verbatim} + | CircularPoint_2 {visitor->begin_CircularPoint_2();} + '(' circular_arc_point ')' + {visitor->end_CircularPoint_2();} + | LineArc_2 {visitor->begin_LineArc_2();} + '(' line_arc_2 ')' + {visitor->end_LineArc_2();} + | CircularArc_2 {visitor->begin_CircularArc_2();} + '('circular_arc_2 ')' + { visitor->end_CircularArc_2();} +\end{verbatim} + +And after stmt block add new lines with definition for circular\_arc\_point ; line\_arc\_2 ; circular\_arc\_2 : + +\begin{verbatim} +circular_arc_point: +error_rules{} + | point_2 + | AlgebraicReal, AlgebraicReal +; +line_arc_2: +error_rules {} + | LineSegment + | point_2 ',' point_2 + | CircularPoint_2 '(' circular_arc_point ')' + ',' CircularPoint_2 '(' circular_arc_point ')' +; +circular_arc_2: +error_rules {} + | Circle_2 '(' circle ')' + | Circle_2 '(' circle ')' ',' CircularPoint_2 '(' circular_arc_point ')' + ',' CircularPoint_2 '(' circular_arc_point ')' + | point_2 ',' point_2 ',' rational +; +\end{verbatim} + +For add new rule for circle\_2 (Point\_2, Rational) change in stmt block this lines : + +\begin{verbatim} + | Circle_2 { visitor->begin_circle_2(); } + '(' point_2 ',' INTEGER { visitor->accept_integer( $6); } ')' + { visitor->end_circle_2(); } +\end{verbatim} + +By this : + +\begin{verbatim} + | Circle_2 { visitor->begin_circle_2(); } + '(' circle_2 ')' { visitor->end_circle_2(); } +\end{verbatim} + +And add after stmt block this lines: + +\begin{verbatim} +circle_2: +error_rules {} +| point_2 ',' rational +| point_2 ',' INTEGER { visitor->accept_integer($3); } +\end{verbatim} + +\subsection{extend the Visitor in benchmark\_visitor.h} +All what is needed for extending the Visitor is to add new virtual functions. It can be easyly made by addition + of these lines in end of definition of benchmark\_visitor class : + +\begin{verbatim} + virtual void begin_CircularArc_2(){ + tnh("begin_CircularArc_2"); + } + virtual void end_CircularArc_2(){ + tnh("end_CircularArc_2"); + } + virtual void begin_LineArc_2(){ + tnh("begin_LineArc_2"); + } + virtual void end_LineArc_2(){ + tnh("end_LineArc_2"); + } + virtual void begin_CircularPoint_2(){ + tnh("begin_CircularPoint_2"); + } + virtual void end_CircularPoint_2(){ + tnh("end_CircularPoint_2"); + } +\end{verbatim} + +Congratulation! Now you have extended vertion of Parser of Benchmark File format. +\end{document} \ No newline at end of file diff --git a/Circular_kernel_2/benchmark/parser/benchmark_lexer.cpp b/Circular_kernel_2/benchmark/parser/benchmark_lexer.cpp new file mode 100644 index 00000000000..058acfd1b24 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_lexer.cpp @@ -0,0 +1,2200 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Id$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 40 +#define YY_END_OF_BUFFER 41 +static yyconst short int yy_accept[261] = + { 0, + 37, 37, 0, 0, 0, 0, 41, 39, 37, 36, + 29, 30, 38, 39, 39, 19, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 28, 40, + 35, 32, 29, 30, 33, 34, 37, 0, 19, 20, + 20, 0, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 28, 0, 20, 0, 20, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 0, 20, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 4, + + 26, 26, 26, 26, 26, 26, 23, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 10, + 14, 26, 26, 26, 26, 26, 26, 7, 26, 26, + 26, 26, 26, 26, 26, 12, 26, 26, 0, 31, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 5, 26, 26, 25, 26, 26, 26, 26, 31, 26, + + 26, 26, 26, 16, 26, 26, 26, 26, 18, 26, + 26, 26, 26, 26, 26, 11, 26, 1, 26, 26, + 26, 22, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 21, 26, 26, 26, 26, 26, 26, 26, + 9, 0, 27, 26, 6, 8, 2, 26, 15, 26, + 26, 27, 13, 26, 26, 3, 26, 17, 24, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 4, 5, 1, 1, 1, 1, 6, + 7, 1, 8, 9, 8, 10, 1, 11, 12, 13, + 14, 11, 11, 11, 11, 11, 11, 1, 1, 1, + 1, 1, 1, 1, 15, 16, 17, 18, 19, 20, + 21, 21, 22, 21, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 21, 36, 21, + 37, 37, 37, 1, 38, 1, 39, 40, 41, 42, + + 43, 44, 45, 46, 47, 21, 48, 49, 50, 51, + 52, 21, 21, 53, 54, 55, 56, 21, 21, 21, + 57, 21, 37, 1, 37, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[58] = + { 0, + 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[265] = + { 0, + 0, 0, 56, 58, 63, 68, 383, 384, 380, 384, + 384, 384, 384, 66, 70, 75, 332, 337, 72, 0, + 332, 327, 330, 354, 68, 319, 335, 346, 0, 384, + 384, 384, 384, 384, 384, 384, 370, 89, 94, 98, + 119, 131, 0, 326, 319, 342, 335, 314, 327, 40, + 325, 315, 322, 71, 336, 328, 67, 321, 304, 336, + 0, 138, 142, 146, 152, 314, 315, 338, 328, 312, + 298, 301, 303, 302, 305, 298, 303, 290, 311, 312, + 291, 284, 298, 292, 320, 156, 160, 297, 290, 312, + 302, 78, 279, 289, 290, 289, 309, 272, 160, 0, + + 296, 288, 270, 273, 270, 270, 0, 268, 270, 284, + 299, 274, 267, 268, 263, 161, 275, 260, 269, 257, + 266, 270, 285, 268, 253, 257, 252, 263, 262, 278, + 269, 260, 258, 252, 240, 241, 241, 279, 278, 237, + 246, 247, 242, 264, 259, 271, 233, 241, 242, 233, + 226, 247, 260, 263, 222, 227, 175, 232, 225, 0, + 0, 221, 250, 231, 218, 241, 246, 0, 218, 226, + 214, 221, 213, 241, 235, 0, 108, 217, 177, 95, + 219, 205, 216, 207, 240, 209, 231, 218, 210, 234, + 0, 217, 220, 0, 218, 191, 191, 203, 145, 228, + + 185, 184, 189, 0, 186, 204, 199, 185, 0, 190, + 193, 214, 189, 182, 173, 0, 189, 0, 183, 170, + 188, 0, 185, 183, 171, 197, 181, 167, 170, 203, + 184, 177, 0, 202, 164, 169, 176, 197, 154, 155, + 0, 190, 192, 175, 0, 0, 0, 162, 0, 144, + 89, 195, 0, 104, 116, 0, 107, 0, 0, 384, + 199, 202, 112, 205 + } ; + +static yyconst short int yy_def[265] = + { 0, + 260, 1, 261, 261, 262, 262, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 264, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 264, 260, 260, 260, 260, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 260, 260, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 260, 260, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 260, 263, + + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, + 263, 260, 260, 263, 263, 263, 263, 263, 263, 263, + 263, 260, 263, 263, 263, 263, 263, 263, 263, 0, + 260, 260, 260, 260 + } ; + +static yyconst short int yy_nxt[442] = + { 0, + 8, 9, 10, 11, 12, 13, 13, 14, 13, 15, + 16, 16, 16, 16, 17, 18, 19, 20, 20, 21, + 20, 22, 20, 23, 24, 20, 20, 25, 26, 27, + 20, 20, 20, 28, 20, 20, 8, 8, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 30, 30, 30, + 30, 30, 30, 30, 30, 32, 33, 34, 35, 36, + 32, 33, 34, 35, 36, 38, 39, 39, 39, 39, + 40, 40, 40, 40, 41, 39, 39, 39, 39, 72, + 73, 56, 30, 42, 30, 46, 199, 199, 47, 40, + + 40, 40, 40, 41, 39, 39, 39, 39, 40, 40, + 40, 40, 42, 81, 43, 82, 62, 42, 48, 57, + 49, 77, 196, 50, 78, 259, 112, 51, 258, 63, + 63, 63, 63, 113, 257, 197, 42, 62, 64, 256, + 62, 65, 65, 65, 65, 86, 199, 199, 87, 87, + 87, 87, 63, 63, 63, 63, 65, 65, 65, 65, + 62, 62, 65, 65, 65, 65, 87, 87, 87, 87, + 87, 87, 87, 87, 120, 136, 179, 179, 179, 179, + 180, 255, 180, 254, 62, 242, 242, 253, 137, 243, + 121, 242, 242, 252, 252, 243, 252, 252, 138, 29, + + 29, 29, 31, 31, 31, 61, 251, 61, 250, 249, + 248, 247, 246, 245, 244, 241, 240, 239, 238, 237, + 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, + 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, + 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, + 206, 205, 204, 203, 202, 201, 200, 198, 195, 194, + 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, + 183, 182, 181, 178, 177, 176, 175, 174, 173, 172, + 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, + 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, + + 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, + 141, 140, 139, 135, 134, 133, 132, 131, 130, 129, + 128, 127, 126, 125, 124, 123, 122, 119, 118, 117, + 116, 115, 114, 111, 110, 109, 108, 107, 106, 105, + 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, + 94, 93, 92, 91, 90, 89, 88, 85, 84, 83, + 80, 79, 76, 75, 74, 71, 70, 69, 68, 67, + 66, 37, 60, 59, 58, 55, 54, 53, 52, 45, + 44, 37, 260, 7, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260 + } ; + +static yyconst short int yy_chk[442] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, + 4, 3, 3, 4, 4, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 14, 14, 14, 14, 14, + 15, 15, 15, 15, 16, 16, 16, 16, 16, 50, + 50, 25, 3, 16, 4, 19, 180, 180, 19, 38, + + 38, 38, 38, 39, 39, 39, 39, 39, 40, 40, + 40, 40, 39, 57, 263, 57, 40, 16, 19, 25, + 19, 54, 177, 19, 54, 257, 92, 19, 255, 41, + 41, 41, 41, 92, 254, 177, 39, 41, 42, 251, + 40, 42, 42, 42, 42, 62, 199, 199, 62, 62, + 62, 62, 63, 63, 63, 63, 64, 64, 64, 64, + 63, 41, 65, 65, 65, 65, 86, 86, 86, 86, + 87, 87, 87, 87, 99, 116, 157, 157, 179, 179, + 157, 250, 179, 248, 63, 231, 231, 244, 116, 231, + 99, 242, 242, 243, 243, 242, 252, 252, 116, 261, + + 261, 261, 262, 262, 262, 264, 240, 264, 239, 238, + 237, 236, 235, 234, 232, 230, 229, 228, 227, 226, + 225, 224, 223, 221, 220, 219, 217, 215, 214, 213, + 212, 211, 210, 208, 207, 206, 205, 203, 202, 201, + 200, 198, 197, 196, 195, 193, 192, 190, 189, 188, + 187, 186, 185, 184, 183, 182, 181, 178, 175, 174, + 173, 172, 171, 170, 169, 167, 166, 165, 164, 163, + 162, 159, 158, 156, 155, 154, 153, 152, 151, 150, + 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, + 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, + + 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, + 119, 118, 117, 115, 114, 113, 112, 111, 110, 109, + 108, 106, 105, 104, 103, 102, 101, 98, 97, 96, + 95, 94, 93, 91, 90, 89, 88, 85, 84, 83, + 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, + 72, 71, 70, 69, 68, 67, 66, 60, 59, 58, + 56, 55, 53, 52, 51, 49, 48, 47, 46, 45, + 44, 37, 28, 27, 26, 24, 23, 22, 21, 18, + 17, 9, 7, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260, 260, 260, 260, 260, 260, 260, 260, 260, 260, + 260 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "benchmark_lexer.l" +#define INITIAL 0 +/************************************************************************** +// Copyright (c) 2004 Max-Planck-Institut Saarbruecken (Germany) +// All rights reserved. +// +// This file is part of BenchmarkParser; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with BenchmarkParser. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Lutz Kettner +**************************************************************************/ +#line 21 "benchmark_lexer.l" +#include +#include +#include +#include +#include + +/* Use C++ std::string as semantic value to communicate with lexer */ +#define YYSTYPE std::string +#include // gets definitions from syntax parser + +// Public lexer interface, check with decl. in benchmark_parser.h +// -------------------------------------------------------------- + +// Current input stream and associated values. +std::istream* benchmark_in = & std::cin; +int benchmark_linenumber = 1; +std::string benchmark_filename( ""); + +// Initialize lexer to scan from input stream with name and linenumber. +// The caller is responsible for the lifetime of 'in' that must live +// during the scan. +void benchmark_init_lexer( + std::istream& in, std::string name, int linenumber = 1); + +// Reset lexer to clean state. +void benchmark_reset_lexer(); + +// Writes a trace of the current include file nesting to the 'out' stream. +// Appends the 'fill' string after each file listed. +void benchmark_include_file_trace( std::ostream& out, std::string fill); + + +// Private lexer interface, all static to keep it local +// ---------------------------------------------------- + +// Stack of input streams: the item stored in the stack. +struct Include_stack_item { + std::istream* in; // input stream + int linenumber; // linenumber in file for error messages + std::string filename; // filename (or similar string) + YY_BUFFER_STATE buffer; // Opaque pointer to flex-buffer struct. + Include_stack_item() {} + Include_stack_item( std::istream* i, int ln, std::string name, + YY_BUFFER_STATE buf) + : in(i), linenumber(ln), filename(name), buffer(buf) {} +}; + +// Stack of input streams is a std::list +typedef std::list Include_stack; + +// We have one static global variable for the stack and some static functions. +// The include stack is except for the trace() debug function not +// accessible from other files (is not polluting namespaces) since +// the Include() function and the <> condition are all handled here. +// The function implementations are at the end of this file. +static Include_stack include_stack; + +// Push current state on include_stack, initializes lexer with new file +// input stream, name, and linenumber. +static void open_include_stream( + std::istream *in, std::string name, int linenumber = 1); + +// Shortcut for open file with name and then call open_include_stream. +// Returns false if the file could not be opened successfully. +static bool open_include_file( std::string name, int linenumber = 1); + +// Closes current input stream. Initializes lexer with new file input stream, +// name, and linenumber, from the include_stack's top. Pop's an element from +// the include_stack. Returns false if include_stack was empty. +static bool close_include_stream(); + + +// Make the lexer read from benchmark_in instead of yyin +#define YY_INPUT(buf,result,max_size) { \ + benchmark_in->read( buf, max_size); \ + result = benchmark_in->gcount(); \ +} + +// Count newlines in the string s +static void count_newlines( const char* s) { + while ( *s) { + if ( *s == '\n') + ++benchmark_linenumber; + ++s; + } +} + +static int comment_nesting = 0; // counts nesting depth of () in Comments + +#define YY_BREAK /* a do nothing */ + +/* -------------------------------------------------------------------- + Parsing Modes: + -- INITIAL: main mode for sequence of tokens + -- IncludeMode: parses lciInclude filename, + -- CommentMode: Comment(...) parsing of nested parantheses + # comments and strings are correctly ignored +-------------------------------------------------------------------- */ +#define IncludeMode 1 + +#define CommentMode 2 + +/* An fnumber consists of up to three parts: + * 1) a sign [+-] + * 2) a mantissa (digits [0-9] with at most one dot in between) + * 3) an exponent [eE]{integer} + * + * Part 1) is optional. + * Part 2) must contain at least one digit, + * but may have leading or trailing dot + * Part 3) is optional iff the mantissa contains a dot + * (so that fnumbers and integers remain distinguishable). + */ + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 148 "benchmark_lexer.l" + + /* Tokens */ + /* --------- */ + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 261 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 384 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 151 "benchmark_lexer.l" +{ return FileFormat;} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 152 "benchmark_lexer.l" +{ return BenchmarkName; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 153 "benchmark_lexer.l" +{ return Classification; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 154 "benchmark_lexer.l" +{ return List; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 155 "benchmark_lexer.l" +{ return Rational; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 156 "benchmark_lexer.l" +{ return Polynomial_1; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 157 "benchmark_lexer.l" +{ return Point_2; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 158 "benchmark_lexer.l" +{ return AlgebraicReal; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 161 "benchmark_lexer.l" +{ return ConicPoint_2; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 162 "benchmark_lexer.l" +{ return Conic_2; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 165 "benchmark_lexer.l" +{ return ConicArc_2; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 166 "benchmark_lexer.l" +{ return Circle_2; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 167 "benchmark_lexer.l" +{ return LineSegment_2; } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 168 "benchmark_lexer.l" +{ return Cubic_2; } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 169 "benchmark_lexer.l" +{ return CircularArc_2;} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 170 "benchmark_lexer.l" +{ return LineArc_2;} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 171 "benchmark_lexer.l" +{return CircularPoint_2;} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 172 "benchmark_lexer.l" +{ return Quadric_3; } + YY_BREAK +/* Integer numbers and float numbers */ +/* --------------------------------- */ +case 19: +YY_RULE_SETUP +#line 177 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return INTEGER; + } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 180 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return FNUMBER; + } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 183 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return MINUS_INFTY; + } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 186 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return PLUS_INFTY; + } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 189 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return VOID; + } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 192 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return COUNTERCLOCKWISE; + } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 195 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return CLOCKWISE; + } + YY_BREAK +/* Non-recognized tokens are errors */ +/* -------------------------------- */ +case 26: +YY_RULE_SETUP +#line 202 "benchmark_lexer.l" +{ yylval = std::string( yytext); + return UNKNOWN_TOKEN; + } + YY_BREAK +/* Handle include files */ +/* ------------------------- */ +case 27: +YY_RULE_SETUP +#line 208 "benchmark_lexer.l" +{ BEGIN( IncludeMode); + count_newlines( yytext); + break; + } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 212 "benchmark_lexer.l" +{ /* remove remaining chars before the ')' */ + int c = yyinput(); + while( c != EOF && c != ')') { + if ( c == '\n') + ++benchmark_linenumber; + c = yyinput(); + } + BEGIN( INITIAL); + if ( c == EOF) { + yylval = std::string( "Reached EOF while" + " parsing include filename '") + + std::string( yytext) + + std::string( "'."); + return ERROR; + } + open_include_file( yytext); + break; + } + YY_BREAK +/* Strings with quoted \" and \\ */ +/* ------------------------------ */ +case 29: +YY_RULE_SETUP +#line 233 "benchmark_lexer.l" +{ int c = yyinput(); + yylval = std::string(""); + bool quoted_char = false; + while (c != EOF && (c!='"' || quoted_char)){ + if ( c == '\n') + ++benchmark_linenumber; + if ( ! quoted_char && c == '\\') { + quoted_char = true; + } else { + quoted_char = false; + yylval.push_back( char(c)); + } + c = yyinput(); + } + if ( c == EOF) { + yylval = std::string( "Reached EOF while" + " parsing string constant '") + + yylval + std::string( "'."); + BEGIN( INITIAL); + return ERROR; + } + if ( YY_START == INITIAL) { + return STRING; + } + yylval = std::string(""); + break; + } + YY_BREAK +/* One line comment starting with # */ +/* -------------------------------- */ +case 30: +YY_RULE_SETUP +#line 263 "benchmark_lexer.l" +{ /* remove remaining chars before the '\n' */ + int c = yyinput(); + while( c != EOF && c != '\n') { + c = yyinput(); + } + if ( c == '\n') + ++benchmark_linenumber; + break; + } + YY_BREAK +/* Nestable and multi-line Comment( ... ) */ +/* -------------------------------------- */ +case 31: +YY_RULE_SETUP +#line 275 "benchmark_lexer.l" +{ BEGIN( CommentMode); + comment_nesting = 1; + count_newlines( yytext); + break; + } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 281 "benchmark_lexer.l" +{ ++benchmark_linenumber; break; } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 283 "benchmark_lexer.l" +{ ++comment_nesting; break; } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 285 "benchmark_lexer.l" +{ if ( --comment_nesting == 0) + BEGIN( INITIAL); + break; + } + YY_BREAK +case YY_STATE_EOF(CommentMode): +#line 290 "benchmark_lexer.l" +{ yylval = std::string( "Reached EOF while " + "parsing 'Comment(...)'."); + BEGIN( INITIAL); + return ERROR; + } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 296 "benchmark_lexer.l" +{ break; } + YY_BREAK +/* Count line numbers for good error messages */ +case 36: +YY_RULE_SETUP +#line 299 "benchmark_lexer.l" +{ ++benchmark_linenumber; break; } + YY_BREAK +/* Ignore white spaces */ +case 37: +YY_RULE_SETUP +#line 302 "benchmark_lexer.l" +{ break; } + YY_BREAK +/* stop scanning at EOF, maybe continue with surrounding file */ +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(IncludeMode): +#line 305 "benchmark_lexer.l" +{ yyterminate(); } + YY_BREAK +/* single characters passed to the parser: */ +case 38: +YY_RULE_SETUP +#line 308 "benchmark_lexer.l" +{ return yytext[0]; } + YY_BREAK +/* all other single characters are errors */ +case 39: +YY_RULE_SETUP +#line 311 "benchmark_lexer.l" +{ yylval = std::string( "Found illegal char '") + + std::string( yytext) + std::string("'."); + return ERROR; + } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 316 "benchmark_lexer.l" +ECHO; + YY_BREAK + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 261 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 261 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 260); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } +#endif /* YY_NO_INPUT */ + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 316 "benchmark_lexer.l" + + +// implements the proper EOF behavior, pop's file from include stack +extern "C" int yywrap() { + if ( close_include_stream()) + return 0; // there was a file waiting on the stack, we continue scan + return 1; // no file in the stack left, we stop scan +} + +// Push current state on include_stack, initializes lexer with new file +// input stream, name, and linenumber. +static void open_include_stream( std::istream *in, std::string name, + int linenumber) +{ + include_stack.push_front( Include_stack_item( + benchmark_in, benchmark_linenumber, benchmark_filename, + YY_CURRENT_BUFFER)); + benchmark_in = in; + benchmark_linenumber = linenumber; + benchmark_filename = name; + yy_switch_to_buffer( yy_create_buffer( 0, YY_BUF_SIZE)); +} + +// Shortcut for open file with name and then call open_include_stream. +// Returns false if the file could not be opened successfully. +static bool open_include_file( std::string name, int linenumber) { + std::ifstream* in = new std::ifstream( name.c_str()); + if ( ! *in) { + delete in; + return false; + } + open_include_stream( in, name, linenumber); + return true; +} + +// Closes current input stream. Initializes lexer with new file input stream, +// name, and linenumber, from the include_stack's top. Pop's an element from +// the include_stack. Returns false if include_stack was empty. +static bool close_include_stream() { + if ( include_stack.empty()) + return false; + delete benchmark_in; // closes the stream + benchmark_in = include_stack.front().in; + benchmark_linenumber = include_stack.front().linenumber; + benchmark_filename = include_stack.front().filename; + yy_delete_buffer( YY_CURRENT_BUFFER); + yy_switch_to_buffer( include_stack.front().buffer); + include_stack.pop_front(); + return true; +} + +// Public interface of the lexer component +// --------------------------------------- + +// Initialize lexer to scan from input stream with name and linenumber. +// The caller is responsible for the lifetime of 'in' that must last +// during the scan. +void benchmark_init_lexer( + std::istream& in, std::string name, int linenumber) +{ + benchmark_reset_lexer(); + benchmark_in = & in; + benchmark_linenumber = linenumber; + benchmark_filename = name; + yy_switch_to_buffer( yy_create_buffer( 0, YY_BUF_SIZE)); +} + +// reset lexer to clean state. Can be used to parse another file then. +void benchmark_reset_lexer() { + while( close_include_stream()) // close all pre-existing include files + ; // empty while body + benchmark_in = & std::cin; + benchmark_linenumber = 1; + benchmark_filename = std::string(""); + yyrestart(0); + BEGIN( INITIAL); +}; + +// Writes a trace of the current include file nesting to the 'out' stream. +void benchmark_include_file_trace( std::ostream& out, std::string fill) { + std::size_t n = include_stack.size(); + for ( Include_stack::const_iterator i = include_stack.begin(); + i != include_stack.end(); ++i) + { + out << std::setw(3) << n-- << ": '" << i->filename << "' line " + << i->linenumber << fill << std::endl; + } +} + +// This summy function is only here to suppress a warning for +// an unused yyunput function +void benchmark_parser_dummy_no_warn_() { + yyunput( 1, 0); +} + +// EOF + diff --git a/Circular_kernel_2/benchmark/parser/benchmark_lexer.l b/Circular_kernel_2/benchmark/parser/benchmark_lexer.l new file mode 100644 index 00000000000..ec7dc3fece2 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_lexer.l @@ -0,0 +1,412 @@ +/************************************************************************** +// Copyright (c) 2004 Max-Planck-Institut Saarbruecken (Germany) +// All rights reserved. +// +// This file is part of BenchmarkParser; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with BenchmarkParser. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Lutz Kettner +**************************************************************************/ + +%{ +#include +#include +#include +#include +#include + +/* Use C++ std::string as semantic value to communicate with lexer */ +#define YYSTYPE std::string +#include // gets definitions from syntax parser + +// Public lexer interface, check with decl. in benchmark_parser.h +// -------------------------------------------------------------- + +// Current input stream and associated values. +std::istream* benchmark_in = & std::cin; +int benchmark_linenumber = 1; +std::string benchmark_filename( ""); + +// Initialize lexer to scan from input stream with name and linenumber. +// The caller is responsible for the lifetime of 'in' that must live +// during the scan. +void benchmark_init_lexer( + std::istream& in, std::string name, int linenumber = 1); + +// Reset lexer to clean state. +void benchmark_reset_lexer(); + +// Writes a trace of the current include file nesting to the 'out' stream. +// Appends the 'fill' string after each file listed. +void benchmark_include_file_trace( std::ostream& out, std::string fill); + + +// Private lexer interface, all static to keep it local +// ---------------------------------------------------- + +// Stack of input streams: the item stored in the stack. +struct Include_stack_item { + std::istream* in; // input stream + int linenumber; // linenumber in file for error messages + std::string filename; // filename (or similar string) + YY_BUFFER_STATE buffer; // Opaque pointer to flex-buffer struct. + Include_stack_item() {} + Include_stack_item( std::istream* i, int ln, std::string name, + YY_BUFFER_STATE buf) + : in(i), linenumber(ln), filename(name), buffer(buf) {} +}; + +// Stack of input streams is a std::list +typedef std::list Include_stack; + +// We have one static global variable for the stack and some static functions. +// The include stack is except for the trace() debug function not +// accessible from other files (is not polluting namespaces) since +// the Include() function and the <> condition are all handled here. +// The function implementations are at the end of this file. +static Include_stack include_stack; + +// Push current state on include_stack, initializes lexer with new file +// input stream, name, and linenumber. +static void open_include_stream( + std::istream *in, std::string name, int linenumber = 1); + +// Shortcut for open file with name and then call open_include_stream. +// Returns false if the file could not be opened successfully. +static bool open_include_file( std::string name, int linenumber = 1); + +// Closes current input stream. Initializes lexer with new file input stream, +// name, and linenumber, from the include_stack's top. Pop's an element from +// the include_stack. Returns false if include_stack was empty. +static bool close_include_stream(); + + +// Make the lexer read from benchmark_in instead of yyin +#define YY_INPUT(buf,result,max_size) { \ + benchmark_in->read( buf, max_size); \ + result = benchmark_in->gcount(); \ +} + +// Count newlines in the string s +static void count_newlines( const char* s) { + while ( *s) { + if ( *s == '\n') + ++benchmark_linenumber; + ++s; + } +} + +static int comment_nesting = 0; // counts nesting depth of () in Comments + +#define YY_BREAK /* a do nothing */ + +/* -------------------------------------------------------------------- + Parsing Modes: + -- INITIAL: main mode for sequence of tokens + -- IncludeMode: parses lciInclude filename, + -- CommentMode: Comment(...) parsing of nested parantheses + # comments and strings are correctly ignored +-------------------------------------------------------------------- */ +%} + +%x IncludeMode +%x CommentMode + +space [\t \r]* +newline [\n] +spcnl [\t \n\r]* +integer [+-]?[0-9]+ +/* An fnumber consists of up to three parts: + * 1) a sign [+-] + * 2) a mantissa (digits [0-9] with at most one dot in between) + * 3) an exponent [eE]{integer} + * + * Part 1) is optional. + * Part 2) must contain at least one digit, + * but may have leading or trailing dot + * Part 3) is optional iff the mantissa contains a dot + * (so that fnumbers and integers remain distinguishable). + */ +fnumber [+-]?(([0-9]+[.][0-9]*|[.][0-9]+)([eE]{integer})?|[0-9]+[eE]{integer}) +idfier [a-zA-Z][a-zA-Z0-9_]* +minus_infty MINUS_INFTY +plus_infty PLUS_INFTY +filename [^ \t\n\r\\\{\}\[\]()]+ +void VOID +counterclockwise COUNTERCLOCKWISE +clockwise CLOCKWISE + +%% + /* Tokens */ + /* --------- */ +"FileFormat" { return FileFormat;} +"BenchmarkName" { return BenchmarkName; } +"Classification" { return Classification; } +"List" { return List; } +"Rational" { return Rational; } +"Polynomial_1" { return Polynomial_1; } +"Point_2" { return Point_2; } +"AlgebraicReal" { return AlgebraicReal; } + + +"ConicPoint_2" { return ConicPoint_2; } +"Conic_2" { return Conic_2; } + + +"ConicArc_2" { return ConicArc_2; } +"Circle_2" { return Circle_2; } +"LineSegment_2" { return LineSegment_2; } +"Cubic_2" { return Cubic_2; } +"CircularArc_2" { return CircularArc_2;} +"LineArc_2" { return LineArc_2;} +"CircularPoint_2" {return CircularPoint_2;} +"Quadric_3" { return Quadric_3; } + + + /* Integer numbers and float numbers */ + /* --------------------------------- */ +{integer} { yylval = std::string( yytext); + return INTEGER; + } +{fnumber} { yylval = std::string( yytext); + return FNUMBER; + } +{minus_infty} { yylval = std::string( yytext); + return MINUS_INFTY; + } +{plus_infty} { yylval = std::string( yytext); + return PLUS_INFTY; + } +{void} { yylval = std::string( yytext); + return VOID; + } +{counterclockwise} { yylval = std::string( yytext); + return COUNTERCLOCKWISE; + } +{clockwise} { yylval = std::string( yytext); + return CLOCKWISE; + } + + + /* Non-recognized tokens are errors */ + /* -------------------------------- */ +{idfier} { yylval = std::string( yytext); + return UNKNOWN_TOKEN; + } + + /* Handle include files */ + /* ------------------------- */ +"IncludeFile"{spcnl}[(]{spcnl} { BEGIN( IncludeMode); + count_newlines( yytext); + break; + } +{filename} { /* remove remaining chars before the ')' */ + int c = yyinput(); + while( c != EOF && c != ')') { + if ( c == '\n') + ++benchmark_linenumber; + c = yyinput(); + } + BEGIN( INITIAL); + if ( c == EOF) { + yylval = std::string( "Reached EOF while" + " parsing include filename '") + + std::string( yytext) + + std::string( "'."); + return ERROR; + } + open_include_file( yytext); + break; + } + + /* Strings with quoted \" and \\ */ + /* ------------------------------ */ +"\"" { int c = yyinput(); + yylval = std::string(""); + bool quoted_char = false; + while (c != EOF && (c!='"' || quoted_char)){ + if ( c == '\n') + ++benchmark_linenumber; + if ( ! quoted_char && c == '\\') { + quoted_char = true; + } else { + quoted_char = false; + yylval.push_back( char(c)); + } + c = yyinput(); + } + if ( c == EOF) { + yylval = std::string( "Reached EOF while" + " parsing string constant '") + + yylval + std::string( "'."); + BEGIN( INITIAL); + return ERROR; + } + if ( YY_START == INITIAL) { + return STRING; + } + yylval = std::string(""); + break; + } + + /* One line comment starting with # */ + /* -------------------------------- */ +"#" { /* remove remaining chars before the '\n' */ + int c = yyinput(); + while( c != EOF && c != '\n') { + c = yyinput(); + } + if ( c == '\n') + ++benchmark_linenumber; + break; + } + + /* Nestable and multi-line Comment( ... ) */ + /* -------------------------------------- */ +"Comment"{spcnl}"("{spcnl} { BEGIN( CommentMode); + comment_nesting = 1; + count_newlines( yytext); + break; + } + +{newline} { ++benchmark_linenumber; break; } + +"(" { ++comment_nesting; break; } + +")" { if ( --comment_nesting == 0) + BEGIN( INITIAL); + break; + } + +<> { yylval = std::string( "Reached EOF while " + "parsing 'Comment(...)'."); + BEGIN( INITIAL); + return ERROR; + } + +. { break; } + + /* Count line numbers for good error messages */ +{newline} { ++benchmark_linenumber; break; } + + /* Ignore white spaces */ +{space} { break; } + + /* stop scanning at EOF, maybe continue with surrounding file */ +<> { yyterminate(); } + + /* single characters passed to the parser: */ +[(),] { return yytext[0]; } + + /* all other single characters are errors */ +. { yylval = std::string( "Found illegal char '") + + std::string( yytext) + std::string("'."); + return ERROR; + } + +%% + +// implements the proper EOF behavior, pop's file from include stack +extern "C" int yywrap() { + if ( close_include_stream()) + return 0; // there was a file waiting on the stack, we continue scan + return 1; // no file in the stack left, we stop scan +} + +// Push current state on include_stack, initializes lexer with new file +// input stream, name, and linenumber. +static void open_include_stream( std::istream *in, std::string name, + int linenumber) +{ + include_stack.push_front( Include_stack_item( + benchmark_in, benchmark_linenumber, benchmark_filename, + YY_CURRENT_BUFFER)); + benchmark_in = in; + benchmark_linenumber = linenumber; + benchmark_filename = name; + yy_switch_to_buffer( yy_create_buffer( 0, YY_BUF_SIZE)); +} + +// Shortcut for open file with name and then call open_include_stream. +// Returns false if the file could not be opened successfully. +static bool open_include_file( std::string name, int linenumber) { + std::ifstream* in = new std::ifstream( name.c_str()); + if ( ! *in) { + delete in; + return false; + } + open_include_stream( in, name, linenumber); + return true; +} + +// Closes current input stream. Initializes lexer with new file input stream, +// name, and linenumber, from the include_stack's top. Pop's an element from +// the include_stack. Returns false if include_stack was empty. +static bool close_include_stream() { + if ( include_stack.empty()) + return false; + delete benchmark_in; // closes the stream + benchmark_in = include_stack.front().in; + benchmark_linenumber = include_stack.front().linenumber; + benchmark_filename = include_stack.front().filename; + yy_delete_buffer( YY_CURRENT_BUFFER); + yy_switch_to_buffer( include_stack.front().buffer); + include_stack.pop_front(); + return true; +} + +// Public interface of the lexer component +// --------------------------------------- + +// Initialize lexer to scan from input stream with name and linenumber. +// The caller is responsible for the lifetime of 'in' that must last +// during the scan. +void benchmark_init_lexer( + std::istream& in, std::string name, int linenumber) +{ + benchmark_reset_lexer(); + benchmark_in = & in; + benchmark_linenumber = linenumber; + benchmark_filename = name; + yy_switch_to_buffer( yy_create_buffer( 0, YY_BUF_SIZE)); +} + +// reset lexer to clean state. Can be used to parse another file then. +void benchmark_reset_lexer() { + while( close_include_stream()) // close all pre-existing include files + ; // empty while body + benchmark_in = & std::cin; + benchmark_linenumber = 1; + benchmark_filename = std::string(""); + yyrestart(0); + BEGIN( INITIAL); +}; + +// Writes a trace of the current include file nesting to the 'out' stream. +void benchmark_include_file_trace( std::ostream& out, std::string fill) { + std::size_t n = include_stack.size(); + for ( Include_stack::const_iterator i = include_stack.begin(); + i != include_stack.end(); ++i) + { + out << std::setw(3) << n-- << ": '" << i->filename << "' line " + << i->linenumber << fill << std::endl; + } +} + +// This summy function is only here to suppress a warning for +// an unused yyunput function +void benchmark_parser_dummy_no_warn_() { + yyunput( 1, 0); +} + +// EOF + diff --git a/Circular_kernel_2/benchmark/parser/benchmark_parser.cpp b/Circular_kernel_2/benchmark/parser/benchmark_parser.cpp new file mode 100644 index 00000000000..80fe5e0d0bc --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_parser.cpp @@ -0,0 +1,1868 @@ +/* A Bison parser, made by GNU Bison 1.875c. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + INTEGER = 258, + FNUMBER = 259, + STRING = 260, + ERROR = 261, + UNKNOWN_TOKEN = 262, + MINUS_INFTY = 263, + PLUS_INFTY = 264, + COUNTERCLOCKWISE = 265, + CLOCKWISE = 266, + VOID = 267, + FileFormat = 268, + BenchmarkName = 269, + Classification = 270, + List = 271, + Rational = 272, + Polynomial_1 = 273, + Point_2 = 274, + AlgebraicReal = 275, + ConicPoint_2 = 276, + LineSegment_2 = 277, + Conic_2 = 278, + CircularArc_2 = 279, + LineArc_2 = 280, + CircularPoint_2 = 281, + ConicArc_2 = 282, + Circle_2 = 283, + Cubic_2 = 284, + Quadric_3 = 285 + }; +#endif +#define INTEGER 258 +#define FNUMBER 259 +#define STRING 260 +#define ERROR 261 +#define UNKNOWN_TOKEN 262 +#define MINUS_INFTY 263 +#define PLUS_INFTY 264 +#define COUNTERCLOCKWISE 265 +#define CLOCKWISE 266 +#define VOID 267 +#define FileFormat 268 +#define BenchmarkName 269 +#define Classification 270 +#define List 271 +#define Rational 272 +#define Polynomial_1 273 +#define Point_2 274 +#define AlgebraicReal 275 +#define ConicPoint_2 276 +#define LineSegment_2 277 +#define Conic_2 278 +#define CircularArc_2 279 +#define LineArc_2 280 +#define CircularPoint_2 281 +#define ConicArc_2 282 +#define Circle_2 283 +#define Cubic_2 284 +#define Quadric_3 285 + + + + +/* Copy the first part of user declarations. */ +#line 21 "benchmark_parser.y" + +/* C/C++ declaration section */ +/* ========================= */ +//#include /* for atoi */ +#include /* for std::string */ +#include /* for std::ifstream */ +#include +#include +#include +static Benchmark_visitor* visitor; /* global visitor used during parsing */ + +/* declaration for flex parser call yylex */ +int yylex( void); + +/* error function called for parse errors */ +void yyerror( char *s) { visitor->parse_error( std::string(s)); } + +/* Use C++ std::string as semantic value to communicate with lexer */ +#define YYSTYPE std::string + +// Public parser interface, check with decl. in benchmark_parser.h +// --------------------------------------------------------------- + +// Opens file 'name' and parses it. Uses visitor 'v' while parsing. +// Returns false if something went wrong. See the visitor for details. +bool benchmark_parse_file( std::string name, Benchmark_visitor* v); + +// Starts parsing from stream 'in' with the associated filename 'name' +// (or analogous meaning for different streams) counting linenumbers +// starting from 'n'. Uses visitor 'v' while parsing. Returns false if +// something went wrong. See the visitor for details of the error reporting. +bool benchmark_parse_stream( std::istream& in, std::string name, + Benchmark_visitor* v, int n); + + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +typedef int YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 214 of yacc.c. */ +#line 183 "benchmark_parser.tab.c" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# endif +# else +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 3 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 322 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 34 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 43 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 92 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 284 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 285 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 31, 33, 2, 2, 32, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned short yyprhs[] = +{ + 0, 0, 3, 4, 6, 9, 14, 16, 25, 36, + 37, 40, 45, 47, 49, 52, 67, 68, 71, 72, + 74, 76, 80, 81, 85, 86, 92, 93, 99, 102, + 103, 111, 114, 137, 160, 161, 167, 168, 174, 175, + 181, 182, 184, 186, 190, 192, 194, 198, 208, 210, + 215, 230, 236, 238, 242, 246, 248, 262, 264, 265, + 266, 281, 282, 288, 290, 292, 296, 298, 305, 314, + 331, 333, 334, 342, 344, 348, 352, 354, 355, 356, + 357, 358, 376, 378, 385, 387, 389, 391, 393, 395, + 397, 399, 401 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 35, 0, -1, -1, 1, -1, 35, 36, -1, 37, + 38, 40, 42, -1, 76, -1, 13, 31, 5, 32, + 3, 32, 3, 33, -1, 13, 31, 5, 32, 3, + 32, 3, 32, 5, 33, -1, -1, 38, 39, -1, + 14, 31, 5, 33, -1, 76, -1, 41, -1, 40, + 41, -1, 15, 31, 5, 32, 5, 32, 5, 32, + 5, 32, 5, 32, 5, 33, -1, -1, 42, 45, + -1, -1, 44, -1, 45, -1, 44, 32, 45, -1, + -1, 1, 46, 76, -1, -1, 16, 47, 31, 43, + 33, -1, -1, 28, 48, 31, 56, 33, -1, 23, + 57, -1, -1, 22, 49, 31, 63, 32, 63, 33, + -1, 27, 58, -1, 29, 31, 3, 32, 3, 32, + 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, + 3, 32, 3, 32, 3, 33, -1, 30, 31, 3, + 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, + 32, 3, 32, 3, 32, 3, 32, 3, 33, -1, + -1, 26, 50, 31, 53, 33, -1, -1, 25, 51, + 31, 54, 33, -1, -1, 24, 52, 31, 55, 33, + -1, -1, 76, -1, 63, -1, 20, 32, 20, -1, + 76, -1, 22, -1, 63, 32, 63, -1, 26, 31, + 53, 33, 32, 26, 31, 53, 33, -1, 76, -1, + 28, 31, 56, 33, -1, 28, 31, 56, 33, 32, + 26, 31, 53, 33, 32, 26, 31, 53, 33, -1, + 63, 32, 63, 32, 72, -1, 76, -1, 63, 32, + 72, -1, 63, 32, 3, -1, 76, -1, 31, 3, + 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, + 33, -1, 76, -1, -1, -1, 31, 23, 59, 57, + 32, 21, 64, 32, 21, 64, 32, 75, 60, 33, + -1, -1, 31, 21, 61, 64, 33, -1, 76, -1, + 3, -1, 62, 32, 3, -1, 76, -1, 19, 31, + 3, 32, 3, 33, -1, 19, 31, 3, 32, 3, + 32, 3, 33, -1, 19, 31, 17, 31, 3, 32, + 3, 33, 32, 17, 31, 3, 32, 3, 33, 33, + -1, 76, -1, -1, 31, 23, 65, 57, 32, 66, + 33, -1, 76, -1, 67, 32, 73, -1, 74, 32, + 3, -1, 76, -1, -1, -1, -1, -1, 20, 68, + 31, 18, 69, 31, 62, 33, 70, 32, 72, 32, + 72, 32, 3, 71, 33, -1, 76, -1, 17, 31, + 3, 32, 3, 33, -1, 3, -1, 74, -1, 8, + -1, 9, -1, 10, -1, 11, -1, 12, -1, 6, + -1, 7, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short yyrline[] = +{ + 0, 103, 103, 105, 106, 110, 114, 115, 119, 125, + 127, 131, 135, 136, 137, 141, 147, 149, 152, 154, + 158, 159, 163, 163, 165, 165, 167, 167, 169, 170, + 170, 173, 175, 180, 186, 186, 189, 189, 192, 192, + 196, 198, 199, 200, 203, 204, 205, 206, 210, 211, + 212, 214, 217, 218, 219, 223, 225, 233, 234, 238, + 234, 243, 243, 250, 251, 252, 257, 258, 260, 262, + 269, 270, 270, 278, 279, 280, 286, 287, 288, 290, + 294, 287, 299, 300, 305, 306, 310, 311, 315, 316, + 317, 326, 327 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "INTEGER", "FNUMBER", "STRING", "ERROR", + "UNKNOWN_TOKEN", "MINUS_INFTY", "PLUS_INFTY", "COUNTERCLOCKWISE", + "CLOCKWISE", "VOID", "FileFormat", "BenchmarkName", "Classification", + "List", "Rational", "Polynomial_1", "Point_2", "AlgebraicReal", + "ConicPoint_2", "LineSegment_2", "Conic_2", "CircularArc_2", "LineArc_2", + "CircularPoint_2", "ConicArc_2", "Circle_2", "Cubic_2", "Quadric_3", + "'('", "','", "')'", "$accept", "input", "file", "file_format", + "file_header_options", "file_header_option", "file_classification", + "classificat", "file_body", "stmt_sequence", "stmt_sequence_non_empty", + "stmt", "@1", "@2", "@3", "@4", "@5", "@6", "@7", "circular_arc_point", + "line_arc_2", "circular_arc_2", "circle_2", "conic_2", "conic_arc_2", + "@8", "@9", "@10", "integer_sequence1", "point_2", "conic_point_2", + "@11", "algorint", "algebraic_real", "@12", "@13", "@14", "@15", + "rational", "inti", "infty", "orientation", "error_rules", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 40, 44, 41 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 34, 35, 35, 35, 36, 37, 37, 37, 38, + 38, 39, 40, 40, 40, 41, 42, 42, 43, 43, + 44, 44, 46, 45, 47, 45, 48, 45, 45, 49, + 45, 45, 45, 45, 50, 45, 51, 45, 52, 45, + 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, + 55, 55, 56, 56, 56, 57, 57, 58, 59, 60, + 58, 61, 58, 62, 62, 62, 63, 63, 63, 63, + 64, 65, 64, 66, 66, 66, 67, 68, 69, 70, + 71, 67, 72, 72, 73, 73, 74, 74, 75, 75, + 75, 76, 76 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 0, 1, 2, 4, 1, 8, 10, 0, + 2, 4, 1, 1, 2, 14, 0, 2, 0, 1, + 1, 3, 0, 3, 0, 5, 0, 5, 2, 0, + 7, 2, 22, 22, 0, 5, 0, 5, 0, 5, + 0, 1, 1, 3, 1, 1, 3, 9, 1, 4, + 14, 5, 1, 3, 3, 1, 13, 1, 0, 0, + 14, 0, 5, 1, 1, 3, 1, 6, 8, 16, + 1, 0, 7, 1, 3, 3, 1, 0, 0, 0, + 0, 17, 1, 6, 1, 1, 1, 1, 1, 1, + 1, 1, 1 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 0, 3, 0, 1, 91, 92, 0, 4, 9, 6, + 0, 0, 0, 0, 0, 10, 16, 13, 12, 0, + 0, 0, 14, 0, 0, 0, 0, 22, 24, 29, + 0, 38, 36, 34, 0, 26, 0, 0, 17, 0, + 11, 0, 0, 0, 0, 0, 28, 55, 0, 0, + 0, 0, 31, 57, 0, 0, 0, 0, 0, 23, + 0, 0, 0, 0, 0, 40, 61, 58, 0, 0, + 0, 0, 7, 0, 0, 19, 20, 0, 0, 66, + 0, 0, 0, 0, 48, 45, 0, 0, 0, 44, + 0, 0, 42, 41, 0, 0, 0, 0, 52, 0, + 0, 0, 0, 25, 0, 0, 0, 0, 0, 39, + 0, 40, 37, 0, 0, 35, 0, 0, 70, 0, + 27, 0, 0, 0, 8, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 46, 43, 71, 62, 0, 54, + 0, 53, 82, 0, 0, 0, 0, 0, 30, 0, + 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, + 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 40, 40, 86, 87, + 77, 0, 0, 0, 73, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 0, 0, 72, 0, 0, 0, + 83, 0, 0, 15, 0, 0, 0, 47, 0, 84, + 74, 85, 75, 0, 0, 0, 0, 0, 0, 78, + 88, 89, 90, 59, 0, 0, 0, 56, 0, 0, + 0, 0, 0, 0, 40, 0, 60, 0, 0, 0, + 0, 64, 0, 63, 0, 0, 0, 50, 0, 79, + 0, 0, 0, 65, 0, 0, 0, 69, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, + 0, 80, 0, 81 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const short yydefgoto[] = +{ + -1, 2, 7, 8, 11, 15, 16, 17, 23, 74, + 75, 38, 42, 43, 54, 44, 50, 49, 48, 91, + 87, 82, 96, 46, 52, 95, 240, 94, 252, 92, + 117, 153, 191, 192, 205, 239, 264, 282, 141, 220, + 193, 233, 93 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -150 +static const short yypact[] = +{ + 117, -150, 147, -150, -150, -150, -21, -150, -150, -150, + 25, 149, 3, 19, 40, -150, 30, -150, -150, 102, + 98, 105, -150, 115, 75, 81, 93, -150, -150, -150, + 6, -150, -150, -150, 8, -150, 96, 119, -150, 126, + -150, 143, 20, 128, 130, 159, -150, -150, 137, 138, + 139, 42, -150, -150, 140, 169, 170, 58, 142, -150, + 56, 68, 144, 14, 12, 48, -150, -150, 68, 145, + 146, 174, -150, 175, 148, 150, -150, 152, 153, -150, + 181, 156, 157, 154, 160, -150, 158, 161, 163, 160, + 164, 165, -150, -150, 10, 6, 166, 168, 160, 185, + 188, 171, 173, -150, 72, 26, 68, 176, 68, -150, + 68, 48, -150, 68, 177, -150, 178, 179, -150, 182, + -150, 41, 183, 184, -150, 197, -150, 186, 172, 180, + 203, 187, 189, 190, -150, -150, -150, -150, 196, -150, + 191, -150, -150, 204, 206, 192, 207, 208, -150, 193, + 194, 129, 195, 6, 10, 216, 198, 199, 223, 100, + 200, 226, 209, -150, 210, 201, 202, 205, 235, 236, + 212, 237, -150, 238, 213, 211, 215, 16, 227, 244, + 217, 218, 246, 219, 220, 251, 48, 48, -150, -150, + -150, 222, 224, 225, 228, 10, 229, 255, 256, 230, + -150, 232, 233, 234, 240, 239, -150, 61, 258, 242, + -150, 243, 245, -150, 252, 265, 247, -150, 253, -150, + -150, -150, -150, 155, 273, 275, 249, 248, 257, -150, + -150, -150, -150, -150, 250, 254, 281, -150, 259, 260, + 261, 282, 284, 263, 48, 106, -150, 264, 266, 285, + 267, -150, 125, -150, 286, 289, 268, -150, 290, -150, + 270, 271, 272, -150, 274, 294, 296, -150, 129, 276, + 277, 278, 301, 304, 129, 279, 280, 283, -150, -150, + 308, -150, 287, -150 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const short yypgoto[] = +{ + -150, -150, -150, -150, -150, -150, -150, 298, -150, -150, + -150, -52, -150, -150, -150, -150, -150, -150, -150, -110, + -150, -150, 214, -93, -150, -150, -150, -150, -150, -57, + -149, -150, -150, -150, -150, -150, -150, -150, -148, -150, + 109, -150, -2 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -77 +static const short yytable[] = +{ + 9, 133, 119, 163, 78, 166, 83, 88, 76, 18, + 10, 97, 4, 5, 4, 5, 4, 5, 4, 5, + 4, 5, 4, 5, 188, 189, 4, 5, 47, 127, + 12, 77, 53, 77, 85, 19, 190, 45, 86, 51, + 59, 116, 81, 128, 139, 14, 209, 4, 5, 129, + 20, 97, 126, 132, 4, 5, 134, 27, 140, 79, + 165, 84, 89, 66, 219, 67, 98, 77, 90, 188, + 189, 21, 28, 27, 4, 5, 203, 204, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 77, 28, -18, + 71, 72, 118, 47, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 25, 79, 24, 98, 39, 79, 251, + 26, 79, 4, 5, 40, -5, 27, -2, 1, 142, + 271, -5, -5, -2, -2, 41, 277, 55, -5, 57, + -2, 28, 171, 172, 250, 4, 5, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 140, 3, 58, 142, + 56, 47, 118, 4, 5, 4, 5, 258, 259, 60, + 6, 61, 62, 13, 14, 230, 231, 232, 63, 64, + 65, 68, 69, 70, 73, 194, 80, 99, 100, 101, + 102, 103, 104, 105, 107, 106, 110, 108, 122, 111, + 109, 123, -66, 118, 112, 113, 114, 135, 115, 120, + 121, 136, 145, 147, 124, 125, 149, 156, 130, 157, + 159, 160, 137, 148, 138, 143, 144, 154, 146, 167, + 150, 151, 155, 152, 158, 161, 162, 164, 170, 174, + 168, 169, 173, 177, 178, 175, 176, 179, 180, 181, + 183, 184, 186, 253, 182, 185, 187, 196, 195, 197, + 198, 199, 200, 201, 202, 206, 207, 208, 211, 212, + -76, 222, 210, 213, 214, 215, 142, 216, 227, 226, + 218, 229, 142, 217, 223, 224, 234, 225, 235, 228, + 236, 237, 241, 238, 243, 247, 242, 248, 256, 260, + 244, 245, 261, 263, 246, 249, 254, 269, 255, 270, + 257, 262, 265, 266, 275, 267, 268, 276, 272, 273, + 274, 281, 278, 279, 22, 280, 221, 0, 0, 0, + 283, 0, 131 +}; + +static const short yycheck[] = +{ + 2, 111, 95, 151, 61, 154, 63, 64, 60, 11, + 31, 68, 6, 7, 6, 7, 6, 7, 6, 7, + 6, 7, 6, 7, 8, 9, 6, 7, 30, 3, + 5, 19, 34, 19, 22, 32, 20, 31, 26, 31, + 42, 31, 28, 17, 3, 15, 195, 6, 7, 106, + 31, 108, 104, 110, 6, 7, 113, 1, 17, 61, + 153, 63, 64, 21, 3, 23, 68, 19, 20, 8, + 9, 31, 16, 1, 6, 7, 186, 187, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 19, 16, 33, + 32, 33, 94, 95, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 5, 106, 3, 108, 32, 110, 3, + 5, 113, 6, 7, 33, 0, 1, 0, 1, 121, + 268, 6, 7, 6, 7, 32, 274, 31, 13, 3, + 13, 16, 32, 33, 244, 6, 7, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 17, 0, 5, 151, + 31, 153, 154, 6, 7, 6, 7, 32, 33, 31, + 13, 31, 3, 14, 15, 10, 11, 12, 31, 31, + 31, 31, 3, 3, 32, 177, 32, 32, 32, 5, + 5, 33, 32, 31, 3, 32, 32, 31, 3, 31, + 33, 3, 32, 195, 33, 32, 32, 20, 33, 33, + 32, 23, 5, 31, 33, 32, 3, 3, 32, 3, + 3, 3, 33, 33, 32, 32, 32, 21, 32, 3, + 33, 32, 31, 33, 32, 32, 32, 32, 5, 3, + 32, 32, 32, 32, 32, 26, 26, 32, 3, 3, + 3, 3, 31, 245, 32, 32, 31, 3, 21, 32, + 32, 5, 33, 33, 3, 33, 32, 32, 3, 3, + 32, 3, 33, 33, 32, 32, 268, 33, 3, 17, + 31, 18, 274, 33, 32, 32, 3, 32, 3, 32, + 31, 33, 32, 26, 3, 3, 32, 3, 3, 3, + 31, 31, 3, 3, 33, 32, 32, 3, 32, 3, + 33, 33, 32, 32, 3, 33, 32, 3, 32, 32, + 32, 3, 33, 33, 16, 32, 207, -1, -1, -1, + 33, -1, 108 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 1, 35, 0, 6, 7, 13, 36, 37, 76, + 31, 38, 5, 14, 15, 39, 40, 41, 76, 32, + 31, 31, 41, 42, 3, 5, 5, 1, 16, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 45, 32, + 33, 32, 46, 47, 49, 31, 57, 76, 52, 51, + 50, 31, 58, 76, 48, 31, 31, 3, 5, 76, + 31, 31, 3, 31, 31, 31, 21, 23, 31, 3, + 3, 32, 33, 32, 43, 44, 45, 19, 63, 76, + 32, 28, 55, 63, 76, 22, 26, 54, 63, 76, + 20, 53, 63, 76, 61, 59, 56, 63, 76, 32, + 32, 5, 5, 33, 32, 31, 32, 3, 31, 33, + 32, 31, 33, 32, 32, 33, 31, 64, 76, 57, + 33, 32, 3, 3, 33, 32, 45, 3, 17, 63, + 32, 56, 63, 53, 63, 20, 23, 33, 32, 3, + 17, 72, 76, 32, 32, 5, 32, 31, 33, 3, + 33, 32, 33, 65, 21, 31, 3, 3, 32, 3, + 3, 32, 32, 72, 32, 57, 64, 3, 32, 32, + 5, 32, 33, 32, 3, 26, 26, 32, 32, 32, + 3, 3, 32, 3, 3, 32, 31, 31, 8, 9, + 20, 66, 67, 74, 76, 21, 3, 32, 32, 5, + 33, 33, 3, 53, 53, 68, 33, 32, 32, 64, + 33, 3, 3, 33, 32, 32, 33, 33, 31, 3, + 73, 74, 3, 32, 32, 32, 17, 3, 32, 18, + 10, 11, 12, 75, 3, 3, 31, 33, 26, 69, + 60, 32, 32, 3, 31, 31, 33, 3, 3, 32, + 53, 3, 62, 76, 32, 32, 3, 33, 32, 33, + 3, 3, 33, 3, 70, 32, 32, 33, 32, 3, + 3, 72, 32, 32, 32, 3, 3, 72, 33, 33, + 32, 3, 71, 33 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up");\ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + ((Current).first_line = (Rhs)[1].first_line, \ + (Current).first_column = (Rhs)[1].first_column, \ + (Current).last_line = (Rhs)[N].last_line, \ + (Current).last_column = (Rhs)[N].last_column) +#endif + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +# define YYDSYMPRINT(Args) \ +do { \ + if (yydebug) \ + yysymprint Args; \ +} while (0) + +# define YYDSYMPRINTF(Title, Token, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Token, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short *bottom, short *top) +#else +static void +yy_stack_print (bottom, top) + short *bottom; + short *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YYDSYMPRINT(Args) +# define YYDSYMPRINTF(Title, Token, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + { + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); +# ifdef YYPRINT + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + } + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yytype, yyvaluep) + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM); +# else +int yyparse (); +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The lookahead symbol. */ +int yychar; + +/* The semantic value of the lookahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yytoken = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyoverflowlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 3: +#line 105 "benchmark_parser.y" + { /* parse error restart here */ ;} + break; + + case 6: +#line 114 "benchmark_parser.y" + {;} + break; + + case 7: +#line 116 "benchmark_parser.y" + { visitor->accept_file_format( yyvsp[-5], + atoi( yyvsp[-3].c_str()), atoi( yyvsp[-1].c_str()), + std::string("")); ;} + break; + + case 8: +#line 120 "benchmark_parser.y" + { visitor->accept_file_format( yyvsp[-7], + atoi( yyvsp[-5].c_str()), atoi( yyvsp[-3].c_str()), + yyvsp[-1]); ;} + break; + + case 11: +#line 131 "benchmark_parser.y" + { visitor->accept_benchmark_name( yyvsp[-1]); ;} + break; + + case 12: +#line 135 "benchmark_parser.y" + {;} + break; + + case 15: +#line 143 "benchmark_parser.y" + { visitor->accept_classification( yyvsp[-11], yyvsp[-9], yyvsp[-7], + yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;} + break; + + case 22: +#line 163 "benchmark_parser.y" + { /* parse error restart here */ ;} + break; + + case 23: +#line 164 "benchmark_parser.y" + {;} + break; + + case 24: +#line 165 "benchmark_parser.y" + { visitor->begin_list(); ;} + break; + + case 25: +#line 166 "benchmark_parser.y" + { visitor->end_list(); ;} + break; + + case 26: +#line 167 "benchmark_parser.y" + { visitor->begin_circle_2(); ;} + break; + + case 27: +#line 168 "benchmark_parser.y" + { visitor->end_circle_2(); ;} + break; + + case 29: +#line 170 "benchmark_parser.y" + { visitor->begin_line_segment_2(); ;} + break; + + case 30: +#line 172 "benchmark_parser.y" + { visitor->end_line_segment_2(); ;} + break; + + case 32: +#line 177 "benchmark_parser.y" + { visitor->accept_cubic_2( yyvsp[-19], yyvsp[-17], yyvsp[-15], yyvsp[-13], + yyvsp[-11], yyvsp[-9], yyvsp[-7], + yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;} + break; + + case 33: +#line 182 "benchmark_parser.y" + { visitor->accept_quadric_3( yyvsp[-19], yyvsp[-17], yyvsp[-15], yyvsp[-13], + yyvsp[-11], yyvsp[-9], yyvsp[-7], + yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;} + break; + + case 34: +#line 186 "benchmark_parser.y" + {visitor->begin_CircularPoint_2();;} + break; + + case 35: +#line 188 "benchmark_parser.y" + {visitor->end_CircularPoint_2();;} + break; + + case 36: +#line 189 "benchmark_parser.y" + {visitor->begin_LineArc_2();;} + break; + + case 37: +#line 191 "benchmark_parser.y" + {visitor->end_LineArc_2();;} + break; + + case 38: +#line 192 "benchmark_parser.y" + { visitor->begin_CircularArc_2();;} + break; + + case 39: +#line 194 "benchmark_parser.y" + { visitor->end_CircularArc_2();;} + break; + + case 41: +#line 198 "benchmark_parser.y" + {;} + break; + + case 44: +#line 203 "benchmark_parser.y" + {;} + break; + + case 48: +#line 210 "benchmark_parser.y" + {;} + break; + + case 52: +#line 217 "benchmark_parser.y" + {;} + break; + + case 54: +#line 219 "benchmark_parser.y" + { visitor->accept_integer(yyvsp[0]); ;} + break; + + case 55: +#line 223 "benchmark_parser.y" + {;} + break; + + case 56: +#line 227 "benchmark_parser.y" + { visitor->accept_conic_2( yyvsp[-11], yyvsp[-9], yyvsp[-7], + yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;} + break; + + case 57: +#line 233 "benchmark_parser.y" + {;} + break; + + case 58: +#line 234 "benchmark_parser.y" + { visitor->begin_conic_arc_2(); ;} + break; + + case 59: +#line 238 "benchmark_parser.y" + { visitor->accept_orientation( yyvsp[0]); ;} + break; + + case 60: +#line 240 "benchmark_parser.y" + { visitor->end_conic_arc_2(); ;} + break; + + case 61: +#line 243 "benchmark_parser.y" + { visitor->begin_conic_arc_2(); ;} + break; + + case 62: +#line 245 "benchmark_parser.y" + { visitor->end_conic_arc_2(); ;} + break; + + case 63: +#line 250 "benchmark_parser.y" + {;} + break; + + case 64: +#line 251 "benchmark_parser.y" + { visitor->accept_integer( yyvsp[0]); ;} + break; + + case 65: +#line 252 "benchmark_parser.y" + { visitor->accept_integer( yyvsp[0]); ;} + break; + + case 66: +#line 257 "benchmark_parser.y" + {;} + break; + + case 67: +#line 259 "benchmark_parser.y" + { visitor->accept_point_2( yyvsp[-3], yyvsp[-1]); ;} + break; + + case 68: +#line 261 "benchmark_parser.y" + { visitor->accept_point_2( yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;} + break; + + case 69: +#line 264 "benchmark_parser.y" + { visitor->accept_point_2( yyvsp[-11], yyvsp[-9], + yyvsp[-4], yyvsp[-2]); ;} + break; + + case 70: +#line 269 "benchmark_parser.y" + {;} + break; + + case 71: +#line 270 "benchmark_parser.y" + { visitor->begin_conic_point_2();;} + break; + + case 72: +#line 273 "benchmark_parser.y" + { visitor->end_conic_point_2(); ;} + break; + + case 73: +#line 278 "benchmark_parser.y" + {;} + break; + + case 75: +#line 280 "benchmark_parser.y" + { visitor->accept_infty( yyvsp[-2]); + visitor->accept_integer( yyvsp[0]); ;} + break; + + case 76: +#line 286 "benchmark_parser.y" + {;} + break; + + case 77: +#line 287 "benchmark_parser.y" + { visitor->begin_algebraic_real(); ;} + break; + + case 78: +#line 288 "benchmark_parser.y" + { visitor->begin_polynomial_1(); ;} + break; + + case 79: +#line 290 "benchmark_parser.y" + { visitor->end_polynomial_1(); ;} + break; + + case 80: +#line 294 "benchmark_parser.y" + { visitor->accept_integer(yyvsp[0]); ;} + break; + + case 81: +#line 295 "benchmark_parser.y" + { visitor->end_algebraic_real(); ;} + break; + + case 82: +#line 299 "benchmark_parser.y" + {;} + break; + + case 83: +#line 301 "benchmark_parser.y" + { visitor->accept_rational( yyvsp[-3], yyvsp[-1]); ;} + break; + + case 84: +#line 305 "benchmark_parser.y" + { visitor->accept_integer( yyvsp[0]); ;} + break; + + case 85: +#line 306 "benchmark_parser.y" + { visitor->accept_infty( yyvsp[0]); ;} + break; + + case 91: +#line 326 "benchmark_parser.y" + { visitor->parse_error( yyvsp[0]); ;} + break; + + case 92: +#line 327 "benchmark_parser.y" + { visitor->unknown_token( yyvsp[0]); ;} + break; + + + } + +/* Line 1000 of yacc.c. */ +#line 1613 "benchmark_parser.tab.c" + + yyvsp -= yylen; + yyssp -= yylen; + + + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[*yyssp], yyvsp); + } + } + else + { + YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); + yydestruct (yytoken, &yylval); + yychar = YYEMPTY; + + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; +#endif + + yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; + + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 332 "benchmark_parser.y" + + +// Opens file 'name' and parses it. Uses visitor 'v' while parsing. +// Returns false if something went wrong. See the visitor for details. +bool benchmark_parse_file( std::string name, Benchmark_visitor* v) { + std::ifstream in( name.c_str()); + if ( ! in) { + v->parse_error( std::string( "cannot open file '") + name + + std::string( "'.")); + return false; + } + visitor = v; + benchmark_init_lexer( in, name, 1); + yyparse(); + return ! v->error(); +} + +// Starts parsing from stream 'in' with the associated filename 'name' +// (or analogous meaning for different streams) counting linenumbers +// starting from 'n'. Uses visitor 'v' while parsing. Returns false if +// something went wrong. See the visitor for details of the error reporting. +bool benchmark_parse_stream( std::istream& in, std::string name, + Benchmark_visitor* v, int n) { + visitor = v; + benchmark_init_lexer( in, name, n); + yyparse(); + return ! v->error(); +} + +/* EOF */ + diff --git a/Circular_kernel_2/benchmark/parser/benchmark_parser.h b/Circular_kernel_2/benchmark/parser/benchmark_parser.h new file mode 100644 index 00000000000..2f8c3a9f544 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_parser.h @@ -0,0 +1,74 @@ +/************************************************************************** +// Copyright (c) 2004 Max-Planck-Institut Saarbruecken (Germany) +// All rights reserved. +// +// This file is part of BenchmarkParser; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with BenchmarkParser. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Lutz Kettner +**************************************************************************/ + +#ifndef BENCHMARK_PARSER_H +#define BENCHMARK_PARSER_H + +#include +#include + +// Magic name and file version number +// ---------------------------------- +// The name and the version number of the benchmark file format. +// If the file has a different format name, it is rejected. If the +// Major number in the file is higher than the major number listed +// here then the file is also rejected. If the number +// in the file is lower than the the number listed here, the parser +// assumes backwards compatibility and continues parsing. +const std::string BENCHMARK_FORMAT_NAME( "AcsBenchmark"); +const int BENCHMARK_FORMAT_MAJOR = 0; +const int BENCHMARK_FORMAT_MINOR = 1; + + +// Public interface of the parser component +// ---------------------------------------- + +// Opens file 'name' and parses it. Uses visitor 'v' while parsing. +// Returns false if something went wrong. See the visitor for details +// of the error reporting. +bool benchmark_parse_file( std::string name, Benchmark_visitor* v); + +// Starts parsing from stream 'in' with the associated filename 'name' +// (or analogous meaning for different streams) counting linenumbers +// starting from 'n'. Uses visitor 'v' while parsing. Returns false if +// something went wrong. See the visitor for details of the error reporting. +bool benchmark_parse_stream( std::istream& in, std::string name, + Benchmark_visitor* v, int n = 1); + + +// Public interface of the lexer component +// --------------------------------------- +// Current input stream and associated values. READ ONLY! Do not modify them! +// The lexer works with internal buffers and would not sync properly! +extern int benchmark_linenumber; +extern std::string benchmark_filename; + +// Initialize lexer to scan from input stream with name and linenumber. +// The caller is responsible for the lifetime of 'in' that must live +// during the scan. Used by benchmark_parse_file and does not have to +// be called separately. +void benchmark_init_lexer( + std::istream& in, std::string name, int linenumber = 1); + +// Writes a trace of the current include file nesting to the 'out' stream. +// Appends the 'fill' string after each file listed. +void benchmark_include_file_trace( std::ostream& out, std::string fill); + + +#endif // BENCHMARK_PARSER_H // diff --git a/Circular_kernel_2/benchmark/parser/benchmark_parser.tab.h b/Circular_kernel_2/benchmark/parser/benchmark_parser.tab.h new file mode 100644 index 00000000000..18fa832d373 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_parser.tab.h @@ -0,0 +1,104 @@ +/* A Bison parser, made by GNU Bison 1.875c. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + INTEGER = 258, + FNUMBER = 259, + STRING = 260, + ERROR = 261, + UNKNOWN_TOKEN = 262, + MINUS_INFTY = 263, + PLUS_INFTY = 264, + COUNTERCLOCKWISE = 265, + CLOCKWISE = 266, + VOID = 267, + FileFormat = 268, + BenchmarkName = 269, + Classification = 270, + List = 271, + Rational = 272, + Polynomial_1 = 273, + Point_2 = 274, + AlgebraicReal = 275, + ConicPoint_2 = 276, + LineSegment_2 = 277, + Conic_2 = 278, + CircularArc_2 = 279, + LineArc_2 = 280, + CircularPoint_2 = 281, + ConicArc_2 = 282, + Circle_2 = 283, + Cubic_2 = 284, + Quadric_3 = 285 + }; +#endif +#define INTEGER 258 +#define FNUMBER 259 +#define STRING 260 +#define ERROR 261 +#define UNKNOWN_TOKEN 262 +#define MINUS_INFTY 263 +#define PLUS_INFTY 264 +#define COUNTERCLOCKWISE 265 +#define CLOCKWISE 266 +#define VOID 267 +#define FileFormat 268 +#define BenchmarkName 269 +#define Classification 270 +#define List 271 +#define Rational 272 +#define Polynomial_1 273 +#define Point_2 274 +#define AlgebraicReal 275 +#define ConicPoint_2 276 +#define LineSegment_2 277 +#define Conic_2 278 +#define CircularArc_2 279 +#define LineArc_2 280 +#define CircularPoint_2 281 +#define ConicArc_2 282 +#define Circle_2 283 +#define Cubic_2 284 +#define Quadric_3 285 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +typedef int YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE yylval; + + + diff --git a/Circular_kernel_2/benchmark/parser/benchmark_parser.y b/Circular_kernel_2/benchmark/parser/benchmark_parser.y new file mode 100644 index 00000000000..2fee14e4447 --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_parser.y @@ -0,0 +1,361 @@ +/************************************************************************** +// Copyright (c) 2004 Max-Planck-Institut Saarbruecken (Germany) +// All rights reserved. +// +// This file is part of BenchmarkParser; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with BenchmarkParser. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Lutz Kettner +// Franziska Ebert +**************************************************************************/ + +%{ +/* C/C++ declaration section */ +/* ========================= */ +//#include /* for atoi */ +#include /* for std::string */ +#include /* for std::ifstream */ +#include +#include +#include +static Benchmark_visitor* visitor; /* global visitor used during parsing */ + +/* declaration for flex parser call yylex */ +int yylex( void); + +/* error function called for parse errors */ +void yyerror( char *s) { visitor->parse_error( std::string(s)); } + +/* Use C++ std::string as semantic value to communicate with lexer */ +#define YYSTYPE std::string + +// Public parser interface, check with decl. in benchmark_parser.h +// --------------------------------------------------------------- + +// Opens file 'name' and parses it. Uses visitor 'v' while parsing. +// Returns false if something went wrong. See the visitor for details. +bool benchmark_parse_file( std::string name, Benchmark_visitor* v); + +// Starts parsing from stream 'in' with the associated filename 'name' +// (or analogous meaning for different streams) counting linenumbers +// starting from 'n'. Uses visitor 'v' while parsing. Returns false if +// something went wrong. See the visitor for details of the error reporting. +bool benchmark_parse_stream( std::istream& in, std::string name, + Benchmark_visitor* v, int n); + +%} + +/* Elementary data types */ +/* --------------------- */ +%token INTEGER +%token FNUMBER +%token STRING +%token ERROR +%token UNKNOWN_TOKEN +%token MINUS_INFTY +%token PLUS_INFTY +%token COUNTERCLOCKWISE +%token CLOCKWISE +%token VOID + +/* Structure tokens */ +/* ---------------- */ +%token FileFormat +%token BenchmarkName +%token Classification + +%token List +%token Rational +%token Polynomial_1 +%token Point_2 +%token AlgebraicReal + + +%token ConicPoint_2 +%token LineSegment_2 +%token Conic_2 + +%token CircularArc_2 +%token LineArc_2 +%token CircularPoint_2 + +%token ConicArc_2 +%token Circle_2 +%token Cubic_2 + + +%token Quadric_3 + + +%% +/* Grammar */ +/* ======= */ + +input: /* an input is a potentially empty sequence of files */ + /* empty */ + | error { /* parse error restart here */ } + | input file +; + +file: /* must start with unique header */ + file_format file_header_options file_classification file_body +; + +file_format: /* mandatory fileformat descriptor */ + error_rules {} + | FileFormat '(' STRING ',' INTEGER ',' INTEGER ')' + { visitor->accept_file_format( $3, + atoi( $5.c_str()), atoi( $7.c_str()), + std::string("")); } + | FileFormat '(' STRING ',' INTEGER ',' INTEGER ',' STRING ')' + { visitor->accept_file_format( $3, + atoi( $5.c_str()), atoi( $7.c_str()), + $9); } +; + +file_header_options: /* sequence of optional file header entries */ + /* empty */ + | file_header_options file_header_option +; + +file_header_option: /* single optional file header entry */ + BenchmarkName '(' STRING ')' { visitor->accept_benchmark_name( $3); } +; + +file_classification: /* */ + error_rules {} + | classificat + | file_classification classificat +; + +classificat: /* */ + Classification '(' STRING ',' STRING ',' STRING ',' STRING ',' + STRING ',' STRING ')' + { visitor->accept_classification( $3, $5, $7, + $9, $11, $13); } +; + +file_body: /* sequence of statements (stmt) */ + /* empty */ + | file_body stmt +; + +stmt_sequence: /* comma separated sequence of statements (stmt) */ + /* empty */ + | stmt_sequence_non_empty +; + +stmt_sequence_non_empty: /* comma separated sequence of statements (stmt) */ + stmt + | stmt_sequence_non_empty ',' stmt +; + +stmt: + error { /* parse error restart here */ } + error_rules {} + | List { visitor->begin_list(); } + '(' stmt_sequence ')' { visitor->end_list(); } + | Circle_2 { visitor->begin_circle_2(); } + '(' circle_2 ')' { visitor->end_circle_2(); } + | Conic_2 conic_2 + | LineSegment_2 { visitor->begin_line_segment_2(); } + '(' point_2 ',' point_2 ')' + { visitor->end_line_segment_2(); } + | ConicArc_2 conic_arc_2 + + | Cubic_2 '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' + INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')' + { visitor->accept_cubic_2( $3, $5, $7, $9, + $11, $13, $15, + $17, $19, $21); } + | Quadric_3 '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' + INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')' + { visitor->accept_quadric_3( $3, $5, $7, $9, + $11, $13, $15, + $17, $19, $21); } + + | CircularPoint_2 {visitor->begin_CircularPoint_2();} + '('circular_arc_point')' + {visitor->end_CircularPoint_2();} + | LineArc_2 {visitor->begin_LineArc_2();} + '('line_arc_2')' + {visitor->end_LineArc_2();} + |CircularArc_2 { visitor->begin_CircularArc_2();} + '('circular_arc_2 ')' + { visitor->end_CircularArc_2();} +; +circular_arc_point: +circular_arc_point: +error_rules{} + | point_2 + | AlgebraicReal ',' AlgebraicReal +; +line_arc_2: +error_rules {} + | LineSegment_2 + | point_2 ',' point_2 + | CircularPoint_2 '(' circular_arc_point ')' + ',' CircularPoint_2 '(' circular_arc_point ')' +; +circular_arc_2: +error_rules {} + | Circle_2 '(' circle_2 ')' + | Circle_2 '(' circle_2 ')' ',' CircularPoint_2 '(' circular_arc_point ')' + ',' CircularPoint_2 '(' circular_arc_point ')' + | point_2 ',' point_2 ',' rational +; +circle_2: +error_rules {} +| point_2 ',' rational +| point_2 ',' INTEGER { visitor->accept_integer($3); } + +; +conic_2: /* */ + error_rules {} + + | '(' INTEGER ',' INTEGER ',' INTEGER ',' + INTEGER ',' INTEGER ',' INTEGER ')' + { visitor->accept_conic_2( $2, $4, $6, + $8, $10, $12); } + + +; +conic_arc_2: /* */ + error_rules {} + | '(' Conic_2 { visitor->begin_conic_arc_2(); } + conic_2 + ',' ConicPoint_2 conic_point_2 + ',' ConicPoint_2 conic_point_2 + ',' orientation { visitor->accept_orientation( $12); } + ')' + { visitor->end_conic_arc_2(); } + + + | '(' ConicPoint_2 { visitor->begin_conic_arc_2(); } + conic_point_2 ')' + { visitor->end_conic_arc_2(); } + +; + +integer_sequence1: /* comma separated integers */ + error_rules {} + | INTEGER { visitor->accept_integer( $1); } + | integer_sequence1 ',' INTEGER { visitor->accept_integer( $3); } +; + + +point_2: /* a 2d point */ + error_rules {} + | Point_2 '(' INTEGER ',' INTEGER ')' + { visitor->accept_point_2( $3, $5); } + | Point_2 '(' INTEGER ',' INTEGER ',' INTEGER ')' + { visitor->accept_point_2( $3, $5, $7); } + | Point_2 '(' Rational '(' INTEGER ',' INTEGER ')' ',' + Rational '(' INTEGER ',' INTEGER ')' ')' + { visitor->accept_point_2( $5, $7, + $12, $14); } +; + +conic_point_2: /* */ + error_rules {} + | '(' Conic_2 { visitor->begin_conic_point_2();} + conic_2 + ',' algorint + ')' { visitor->end_conic_point_2(); } + +; + +algorint: /* */ + error_rules {} + | algebraic_real ',' inti + | infty ',' INTEGER { visitor->accept_infty( $1); + visitor->accept_integer( $3); } +; + + +algebraic_real: /* */ + error_rules {} + | AlgebraicReal { visitor->begin_algebraic_real(); } + '(' Polynomial_1 { visitor->begin_polynomial_1(); } + '(' integer_sequence1 ')' + { visitor->end_polynomial_1(); } + + ',' rational + ',' rational + ',' INTEGER { visitor->accept_integer($15); } + ')' { visitor->end_algebraic_real(); } +; + +rational: /* */ + error_rules {} + | Rational '(' INTEGER ',' INTEGER ')' + { visitor->accept_rational( $3, $5); } +; + +inti: /* */ + INTEGER { visitor->accept_integer( $1); } + | infty { visitor->accept_infty( $1); } +; + +infty: /* */ + MINUS_INFTY + | PLUS_INFTY +; + +orientation: /* */ + COUNTERCLOCKWISE + | CLOCKWISE + | VOID +; + +double_val: /* a double value can be either an FNUMBER or an INTEGER */ + FNUMBER + | INTEGER { visitor->accept_integer( $1); } +; + +error_rules: + ERROR { visitor->parse_error( $1); } + | UNKNOWN_TOKEN { visitor->unknown_token( $1); } +; + +/* End of Grammar */ +/* ============== */ +%% + +// Opens file 'name' and parses it. Uses visitor 'v' while parsing. +// Returns false if something went wrong. See the visitor for details. +bool benchmark_parse_file( std::string name, Benchmark_visitor* v) { + std::ifstream in( name.c_str()); + if ( ! in) { + v->parse_error( std::string( "cannot open file '") + name + + std::string( "'.")); + return false; + } + visitor = v; + benchmark_init_lexer( in, name, 1); + yyparse(); + return ! v->error(); +} + +// Starts parsing from stream 'in' with the associated filename 'name' +// (or analogous meaning for different streams) counting linenumbers +// starting from 'n'. Uses visitor 'v' while parsing. Returns false if +// something went wrong. See the visitor for details of the error reporting. +bool benchmark_parse_stream( std::istream& in, std::string name, + Benchmark_visitor* v, int n) { + visitor = v; + benchmark_init_lexer( in, name, n); + yyparse(); + return ! v->error(); +} + +/* EOF */ diff --git a/Circular_kernel_2/benchmark/parser/benchmark_visitor.cpp b/Circular_kernel_2/benchmark/parser/benchmark_visitor.cpp new file mode 100644 index 00000000000..eaf893fd19b --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/benchmark_visitor.cpp @@ -0,0 +1,107 @@ +/************************************************************************** +// Copyright (c) 2004 Max-Planck-Institut Saarbruecken (Germany) +// All rights reserved. +// +// This file is part of BenchmarkParser; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with BenchmarkParser. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Lutz Kettner +**************************************************************************/ + +#include +#include +#include +#include +#include + +void Benchmark_visitor::error_handler( std::string s) { + std::ostringstream message; + message << "ERROR: Benchmark_parser: " << benchmark_filename << " line " + << benchmark_linenumber << ": " << s; + if ( ! m_error) { + m_error = true; + m_error_message = message.str(); + } + if ( m_mode & PRINT_ERRORS) { + std::cerr << message.str() << std::endl; + } + switch ( m_mode & 0x06) { + case THROW_ERRORS: + throw Benchmark_parser_exception( message.str()); + break; + case EXIT_ERRORS: + exit( 1); + break; + default: + break; + } +} + +void Benchmark_visitor::parse_error( std::string s) { + //error_handler( std::string("parse error: ") + s); + error_handler( s); +} + +void Benchmark_visitor::unknown_token( std::string s) { + error_handler( std::string("unknown token '") + s + + std::string("' found.")); +} + +void Benchmark_visitor::token_not_handled( std::string s) { + error_handler( std::string("known token '") + s + + std::string("' found but not handled by visitor.")); +} + +void Benchmark_visitor::reset_header() { + m_major = -1; + m_minor = -1; + m_format_options = std::string(""); + m_benchmark_name = std::string(""); +} + +void Benchmark_visitor::accept_file_format( + std::string s, int major, int minor, std::string options) +{ + reset_header(); + if ( s != BENCHMARK_FORMAT_NAME) { + error_handler( std::string( "wrong file format '") + s + + std::string("', must be '") + BENCHMARK_FORMAT_NAME + + std::string("'.")); + return; + } + if ( major > BENCHMARK_FORMAT_MAJOR) { + std::ostringstream message; + message << "version major " << major << " is larger than " + << BENCHMARK_FORMAT_MAJOR << " what the parser understands."; + error_handler( message.str()); + return; + } + m_major = major; + m_minor = minor; + // Options are comma separated. We add one left and one right to + // have simple contains-an-option ",OPT," queries. + m_format_options = std::string(",") + options + std::string(","); +} + +void Benchmark_visitor::accept_benchmark_name( std::string s) { + m_benchmark_name = s; +} + +void Benchmark_visitor::accept_classification( std::string problem, + std::string geom, + std::string clas, + std::string family, + std::string instance, + std::string release) { + std::cout<<"inclassifi visitor" < + +// Exception thrown by Benchmark_visitor if mode is THROW_ERRORS +struct Benchmark_parser_exception { + std::string message; + Benchmark_parser_exception() {} + Benchmark_parser_exception( std::string s) : message(s) {} +}; + +// Visitor pattern for the benchmark parser +class Benchmark_visitor { +public: + enum Error_mode { IGNORE_ERRORS = 0, PRINT_ERRORS = 1, + THROW_ERRORS = 2, EXIT_ERRORS = 4 }; +protected: + // error handling + int m_mode; // Error_mode or'ed together + bool m_error; // flags if an error has occured + std::string m_error_message; // error message kept from last error + virtual void error_handler( std::string s); + + // information from the benchmark file already understood and parsed + int m_major; + int m_minor; + std::string m_format_options; + std::string m_benchmark_name; + +public: + Benchmark_visitor( int mode = PRINT_ERRORS ) + : m_mode(mode), m_error( false), m_error_message(""), + m_major(-1), m_minor(-1) {} + virtual ~Benchmark_visitor() {} + + // error status and mode + bool error() const { return m_error; } + std::string error_message() const { return m_error_message; } + void reset_error() { + m_error = false; + m_error_message = std::string( ""); + } + + // information from the benchmark file already understood and parsed + int version_major() const { return m_major; } + int version_minor() const { return m_minor; } + + virtual void reset_header(); + + // Options are comma separated. We have also a comma left and one right + // to have simple contains-an-option ",OPT," queries. + std::string format_options() const { return m_format_options; } + std::string benchmark_name() const { return m_benchmark_name; } + + // error handlers + virtual void parse_error( std::string s); + virtual void unknown_token( std::string s); + virtual void token_not_handled( std::string s); + void tnh( std::string s) { token_not_handled(s); } // shortcut + + // file header entries + virtual void accept_file_format( std::string s, int major, int minor, + std::string options); + virtual void accept_benchmark_name( std::string s); + virtual void accept_classification( std::string problem, + std::string geom, + std::string clas, + std::string family, + std::string instance, + std::string release); + + // terminal nodes + virtual void accept_infty( std::string s) { tnh( "Infty"); } + virtual void accept_orientation( std::string s) { tnh( "Orientation"); } + + virtual void accept_integer( std::string s) { tnh( "Integer"); } + virtual void accept_rational( std::string num, std::string denom) { + tnh( "Rational"); + } + virtual void accept_fnumber( double d) { tnh( "Fnumber"); } + virtual void accept_string( std::string s) { tnh( "String"); } + virtual void accept_minus_infty (std::string s) { tnh("Minus_infty"); } + virtual void accept_plus_infty (std::string s) { tnh("Plus_infty"); } + virtual void accept_counter (std::string s) { tnh("Counterclockwise"); } + virtual void accept_clockwise (std::string s) { tnh("Clockwise"); } + virtual void accept_void (std::string s) { tnh("Void"); } + + virtual void accept_point_2( std::string x, std::string y) { + tnh( "Point_2(x,y)"); + } + virtual void accept_point_2( std::string x, std::string y, std::string w) { + tnh( "Point_2(x,y,w)"); + } + virtual void accept_point_2( std::string x_num, std::string x_denom, + std::string y_num, std::string y_denom) { + tnh( "Point_2(x_num, x_denom, y_num, y_denom)"); + } + + virtual void begin_algebraic_real() { tnh( "Begin_algebraic_real" ); } + virtual void end_algebraic_real() { tnh( "End_algebraic_real" ); } + + + virtual void begin_conic_point_2() { + tnh( "Begin_conic_point_2" ); + } + + virtual void end_conic_point_2() { + tnh( "End_conic_point_2" ); + } + + // non-terminal nodes + virtual void begin_list() { tnh( "Begin_list"); } + virtual void end_list() { tnh( "End_list"); } + + virtual void begin_polynomial_1() { tnh( "Begin_polynomial_1"); } + virtual void end_polynomial_1() { tnh( "End_polynomial_1"); } + + virtual void begin_line_segment_2() { tnh( "Begin_line_segment_2"); } + virtual void end_line_segment_2() { tnh( "End_line_segment_2"); } + + virtual void accept_conic_2(std::string A, std::string B, std::string C, + std::string D, std::string E, std::string F) { + tnh("Conic_2"); + } + + + virtual void begin_conic_arc_2() { tnh( "Begin_conic_arc_2" );} + virtual void end_conic_arc_2() { tnh( "End_conic_arc_2" );} + + virtual void begin_circle_2() { tnh("Begin_circle_2"); } + virtual void end_circle_2() { tnh("End_circle_2"); } + + virtual void accept_cubic_2(std::string A, std::string B, std::string C, + std::string D, std::string E, std::string F, + std::string G, std::string H, std::string K, + std::string L) { + tnh("Cubic_2"); + } + + + virtual void accept_quadric_3(std::string A, std::string B, std::string C, + std::string D, std::string E, std::string F, + std::string G, std::string H, std::string K, + std::string L) { + tnh("Quadric_3"); + } + virtual void begin_CircularArc_2(){ + tnh("begin_CircularArc_2"); + } + virtual void end_CircularArc_2(){ + tnh("end_CircularArc_2"); + } + virtual void begin_LineArc_2(){ + tnh("begin_LineArc_2"); + } + virtual void end_LineArc_2(){ + tnh("end_LineArc_2"); + } + virtual void begin_CircularPoint_2(){ + tnh("begin_CircularPoint_2"); + } + virtual void end_CircularPoint_2(){ + tnh("end_CircularPoint_2"); + } +}; + + +#endif // BENCHMARK_VISITOR_H // diff --git a/Circular_kernel_2/benchmark/parser/readme.txt b/Circular_kernel_2/benchmark/parser/readme.txt new file mode 100644 index 00000000000..62ec4abf2bc --- /dev/null +++ b/Circular_kernel_2/benchmark/parser/readme.txt @@ -0,0 +1 @@ +This source of extendet parser. By using report.tex. You can easily extend it in you own way. diff --git a/Circular_kernel_2/benchmark/readme.doc b/Circular_kernel_2/benchmark/readme.doc new file mode 100644 index 00000000000..a2505cdab06 Binary files /dev/null and b/Circular_kernel_2/benchmark/readme.doc differ diff --git a/Circular_kernel_2/benchmark/readme.pdf b/Circular_kernel_2/benchmark/readme.pdf new file mode 100644 index 00000000000..ceeedc2e950 --- /dev/null +++ b/Circular_kernel_2/benchmark/readme.pdf @@ -0,0 +1,3107 @@ +%PDF-1.4 +% +1 0 obj +<< /Length 2 0 R +>> +stream +0 w +q 0 0.1 595.3 841.9 re W* n +q 0 0 0 rg +BT +266.6 740.6 Td /F1 18 Tf <01> Tj +11.9 0 Td <02> Tj +7.9 0 Td <03> Tj +7.8 0 Td <04> Tj +8.9 0 Td <05> Tj +13.8 0 Td <02> Tj +7.8 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 701.3 Td /F1 10 Tf <07> Tj +5.4 0 Td <0809> Tj +8.3 0 Td <0A> Tj +2.4 0 Td <05> Tj +7.6 0 Td <0B> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.6 0 Td <0E> Tj +2.8 0 Td <0F> Tj +4.8 0 Td <100A> Tj +7.3 0 Td <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.2 0 Td <05> Tj +7.6 0 Td <0309> Tj +7.7 0 Td <13> Tj +4.8 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <15> Tj +3.2 0 Td <16> Tj +1.8 0 Td <05> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.9 0 Td <14> Tj +3.8 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <10> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <18> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0214> Tj +8.1 0 Td <1B> Tj +ET +Q +q 0 0 0 rg +BT +90 676.1 Td /F1 10 Tf <1C> Tj +4.9 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +104.2 676.1 Td /F1 10 Tf <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.1 0 Td <05> Tj +7.7 0 Td <0309> Tj +7.6 0 Td <13> Tj +4.9 0 Td <14> Tj +3.8 0 Td <1E0309> Tj +12.6 0 Td <09> Tj +3.3 0 Td <030F> Tj +9.2 0 Td <10> Tj +4.8 0 Td <0205> Tj +12 0 Td <02> Tj +4.3 0 Td <0F0D> Tj +7.6 0 Td <061F> Tj +ET +Q +q 0 0 0 rg +BT +90 650.9 Td /F1 10 Tf <20> Tj +4.9 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +104.2 650.9 Td /F1 10 Tf <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.1 0 Td <05> Tj +7.7 0 Td <0309> Tj +7.6 0 Td <13> Tj +5 0 Td <06> Tj +2.4 0 Td <12> Tj +ET +Q +q 0 0 0 rg +BT +90 625.7 Td /F1 10 Tf <18> Tj +4.9 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +104.2 625.7 Td /F1 10 Tf <15> Tj +3.2 0 Td <0F> Tj +4.8 0 Td <21> Tj +4.9 0 Td <17> Tj +4.8 0 Td <0D> Tj +2.7 0 Td <1E04> Tj +9.8 0 Td <030D> Tj +7 0 Td <030612> Tj +ET +Q +q 0 0 0 rg +BT +90 600.5 Td /F1 10 Tf <15> Tj +3.2 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <12> Tj +4.9 0 Td <020A> Tj +6.8 0 Td <19> Tj +3.2 0 Td <08> Tj +4.9 0 Td <1A> Tj +2.8 0 Td <1A> Tj +2.7 0 Td <08> Tj +4.9 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <10> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <15> Tj +3.2 0 Td <16> Tj +1.7 0 Td <1A> Tj +2.8 0 Td <1A> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <022321> Tj +14.2 0 Td <1A> Tj +2.7 0 Td <030E> Tj +7.1 0 Td <0F> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <12030D> Tj +12 0 Td <0A> Tj +2.4 0 Td <1516> Tj +5 0 Td <05> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.9 0 Td <14> Tj +3.8 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <10> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0809> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <12030D> Tj +12 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 576.1 Td /F2 10 Tf <01> Tj +5.5 0 Td <02> Tj +4.3 0 Td <03> Tj +5.5 0 Td <04> Tj +4.3 0 Td <05> Tj +5.4 0 Td <06> Tj +8.2 0 Td <07> Tj +4.9 0 Td <08> Tj +4.3 0 Td <09> Tj +5.5 0 Td <0A> Tj +3.8 0 Td <0B> Tj +5 0 Td <07> Tj +4.8 0 Td <08> Tj +4.4 0 Td <08> Tj +4.3 0 Td <07> Tj +4.9 0 Td <03> Tj +5.5 0 Td <0C> Tj +4.9 0 Td <02> Tj +4.3 0 Td <06> Tj +8.2 0 Td <02> Tj +4.3 0 Td <03> Tj +5.4 0 Td <0D> Tj +3.3 0 Td <0E> Tj +2.4 0 Td <0F> Tj +7 0 Td <10> Tj +2.4 0 Td <11> Tj +ET +Q +q 0 0 0 rg +BT +216 576.1 Td /F1 10 Tf <150D> Tj +5.9 0 Td <16> Tj +1.8 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <1202> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <05> Tj +7.7 0 Td <030E> Tj +7 0 Td <0F0A> Tj +7.3 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <020A> Tj +6.8 0 Td <061F> Tj +9.1 0 Td <0A> Tj +2.4 0 Td <06> Tj +2.5 0 Td <0A> Tj +2.4 0 Td <24> Tj +7.1 0 Td <020902> Tj +12 0 Td <0A> Tj +2.4 0 Td <15> Tj +3.2 0 Td <16> Tj +1.8 0 Td <05> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.7 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <100A> Tj +7.3 0 Td <05> Tj +7.6 0 Td <030E> Tj +7 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <0B21> Tj +9.8 0 Td <02> Tj +4.3 0 Td <04> Tj +4.9 0 Td <0219> Tj +7.6 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <09> Tj +3.2 0 Td <0203040E> Tj +16.4 0 Td <0F> Tj +4.8 0 Td <10> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0821> Tj +9.8 0 Td <0D> Tj +2.7 0 Td <0E> Tj +2.7 0 Td <08> Tj +4.9 0 Td <0F14> Tj +ET +Q +q 0 0 0 rg +BT +90 565.1 Td /F1 10 Tf <19> Tj +3.3 0 Td <09> Tj +3.3 0 Td <0805> Tj +12.6 0 Td <0A> Tj +2.4 0 Td <0C08> Tj +9.3 0 Td <05> Tj +7.6 0 Td <05> Tj +7.7 0 Td <030F04> Tj +14.2 0 Td <0A> Tj +2.4 0 Td <1A> Tj +2.7 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <0206> Tj +6.8 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 538.9 Td /F2 10 Tf <01> Tj +5.5 0 Td <02> Tj +4.3 0 Td <03> Tj +5.5 0 Td <04> Tj +4.3 0 Td <05> Tj +5.4 0 Td <06> Tj +8.2 0 Td <07> Tj +4.9 0 Td <08> Tj +4.3 0 Td <09> Tj +5.6 0 Td <0E> Tj +2.3 0 Td <05> Tj +5.4 0 Td <10> Tj +2.4 0 Td <11> Tj +3.2 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +153.7 538.9 Td /F1 10 Tf <24> Tj +7.1 0 Td <020902> Tj +12 0 Td <0A> Tj +2.4 0 Td <150D> Tj +5.9 0 Td <16> Tj +1.8 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <1202> Tj +9.2 0 Td <03040209> Tj +17 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.2 0 Td <0E> Tj +2.8 0 Td <1A> Tj +2.7 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <12> Tj +4.8 0 Td <020902> Tj +12.1 0 Td <0A> Tj +2.4 0 Td <15> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <04> Tj +4.9 0 Td <0219> Tj +7.6 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <0204> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <0C1A> Tj +7.1 0 Td <0314> Tj +8.1 0 Td <14> Tj +4 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +318.5 538.9 Td /F1 12 Tf <11> Tj +7.9 0 Td <02> Tj +5.1 0 Td <0F> Tj +5.8 0 Td <0C> Tj +5.2 0 Td <12> Tj +5.9 0 Td <06> Tj +3 0 Td <0A> Tj +3 0 Td <15> Tj +3.8 0 Td <16> Tj +2.2 0 Td <1A> Tj +3.2 0 Td <1A> Tj +3.5 0 Td <0A> Tj +3 0 Td <0E> Tj +3.2 0 Td <0F> Tj +5.8 0 Td <0D> Tj +3.3 0 Td <09> Tj +3.8 0 Td <08> Tj +5.8 0 Td <04> Tj +5.9 0 Td <17> Tj +5.9 0 Td <0C> Tj +5.2 0 Td <02> Tj +5.4 0 Td <0A> Tj +3 0 Td <03> Tj +5.2 0 Td <1A> Tj +3.3 0 Td <1A> Tj +3.3 0 Td <0A> Tj +3 0 Td <05> Tj +9.2 0 Td <02> Tj +5.2 0 Td <05> Tj +9.1 0 Td <1D> Tj +5.9 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <03> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <04> Tj +ET +Q +q 0 0 0 rg +BT +90 525.6 Td /F1 12 Tf <03> Tj +5.2 0 Td <0E> Tj +3.3 0 Td <05> Tj +9.2 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <19> Tj +3.9 0 Td <0A> Tj +3 0 Td <0D> Tj +3.3 0 Td <12> Tj +5.8 0 Td <0E> Tj +3.3 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <0C> Tj +5.3 0 Td <1A> Tj +3.2 0 Td <03> Tj +5.2 0 Td <14> Tj +4.5 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <1A> Tj +3.3 0 Td <03> Tj +5.2 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <06> Tj +3 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 500.8 Td /F2 10 Tf <12> Tj +3.9 0 Td <03> Tj +5.4 0 Td <13> Tj +5.6 0 Td <14> Tj +5.5 0 Td <0D> Tj +3.3 0 Td <0B> Tj +4.9 0 Td <15> Tj +5.5 0 Td <07> Tj +4.9 0 Td <0D> Tj +3.3 0 Td <07> Tj +4.9 0 Td <0E> Tj +2.5 0 Td <05> Tj +5.4 0 Td <10> Tj +2.4 0 Td <11> Tj +3.2 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +153.1 500.8 Td /F1 10 Tf <24> Tj +7.1 0 Td <020902> Tj +12 0 Td <0A> Tj +2.4 0 Td <15> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <04> Tj +4.9 0 Td <0219> Tj +7.6 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <02040A> Tj +11.6 0 Td <19> Tj +3.2 0 Td <17> Tj +4.9 0 Td <0F> Tj +4.9 0 Td <0C0D> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <08> Tj +4.8 0 Td <0F> Tj +5 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.2 0 Td <0809> Tj +8.3 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <09> Tj +3.3 0 Td <02030D> Tj +11.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <100A> Tj +7.3 0 Td <04> Tj +4.9 0 Td <030D> Tj +7 0 Td <030A> Tj +6.8 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <040A> Tj +7.3 0 Td <09020304> Tj +16.9 0 Td <0E> Tj +2.7 0 Td <0F10> Tj +9.7 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <08> Tj +4.9 0 Td <09> Tj +3.3 0 Td <05> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <021406> Tj +ET +Q +q 0 0 0 rg +BT +90 476.5 Td /F2 10 Tf <0F> Tj +7.1 0 Td <16> Tj +2.7 0 Td <07> Tj +5 0 Td <0A> Tj +3.8 0 Td <0A> Tj +3.7 0 Td <10> Tj +2.4 0 Td <17> Tj +6.6 0 Td <02> Tj +4.3 0 Td <03> Tj +5.5 0 Td <04> Tj +4.3 0 Td <05> Tj +5.5 0 Td <0E> Tj +ET +Q +q 1 0 0 1 90 476.5 cm +0.6 w 0 0 0 RG +0 -0.9 m 53.2 -0.9 l S +Q +q 0 0 0 rg +BT +90 452.1 Td /F1 10 Tf <25> Tj +6 0 Td <120E> Tj +7.6 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <0C1A> Tj +7.1 0 Td <03> Tj +4.4 0 Td <1414> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <120314> Tj +13.1 0 Td <0A> Tj +2.4 0 Td <18> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.2 0 Td <17> Tj +4.9 0 Td <0F0C0D> Tj +12 0 Td <0E> Tj +2.7 0 Td <08> Tj +4.8 0 Td <0F14> Tj +8.8 0 Td <1B> Tj +ET +Q +q 0 0 0 rg +BT +90 430 Td /F1 10 Tf <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <0914> Tj +7.1 0 Td <0D> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <26> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.6 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <04> Tj +4.9 0 Td <030D> Tj +7 0 Td <03> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <14020D> Tj +10.9 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.6 0 Td <0F0A> Tj +7.3 0 Td <27> Tj +7.1 0 Td <09> Tj +3.3 0 Td <0C> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <0C080F0D> Tj +16.9 0 Td <030E> Tj +7 0 Td <0F> Tj +4.9 0 Td <0209> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <28> Tj +ET +Q +q 0 0 0 rg +BT +90 407.9 Td /F1 10 Tf <14020C08> Tj +17.4 0 Td <0F04> Tj +9.9 0 Td <0A> Tj +2.4 0 Td <26> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <2117> Tj +9.7 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <1202> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <04030D> Tj +12 0 Td <030A> Tj +6.8 0 Td <14> Tj +3.8 0 Td <020D> Tj +7.1 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <08> Tj +5 0 Td <0A> Tj +2.4 0 Td <0309> Tj +7.6 0 Td <09030F> Tj +12.5 0 Td <100205> Tj +16.8 0 Td <02> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <04> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <05> Tj +7.7 0 Td <0313> Tj +9.2 0 Td <020A> Tj +6.8 0 Td <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.1 0 Td <05> Tj +7.6 0 Td <03> Tj +4.4 0 Td <09> Tj +3.3 0 Td <13> Tj +5 0 Td <1428> Tj +6.5 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 385.8 Td /F1 10 Tf <0D> Tj +2.7 0 Td <120E> Tj +7.7 0 Td <09> Tj +3.3 0 Td <04> Tj +5 0 Td <0A> Tj +2.4 0 Td <26> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.7 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <12> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <05> Tj +7.6 0 Td <1A> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <04> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <1A> Tj +2.7 0 Td <030D> Tj +7.1 0 Td <0223> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D> Tj +9.3 0 Td <1A> Tj +2.7 0 Td <0214> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.8 0 Td <12020902> Tj +16.9 0 Td <0A> Tj +2.4 0 Td <090214> Tj +11.4 0 Td <171A> Tj +7.7 0 Td <0D> Tj +2.7 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <1D02> Tj +9.2 0 Td <0F0C1205> Tj +21.7 0 Td <03> Tj +4.4 0 Td <09> Tj +3.3 0 Td <13> Tj +4.9 0 Td <14> Tj +3.9 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 361.5 Td /F2 10 Tf <0F> Tj +7.1 0 Td <08> Tj +4.4 0 Td <02> Tj +4.3 0 Td <07> Tj +5 0 Td <0D> Tj +3.2 0 Td <18> Tj +2.7 0 Td <19> Tj +4.9 0 Td <03> Tj +5.5 0 Td <11> Tj +ET +Q +q 1 0 0 1 90 361.5 cm +0.6 w 0 0 0 RG +0 -0.9 m 40.2 -0.9 l S +Q +q 0 0 0 rg +BT +90 337.1 Td /F1 10 Tf <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F0C120A> Tj +16.6 0 Td <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.2 0 Td <05> Tj +7.6 0 Td <0309> Tj +7.6 0 Td <13> Tj +4.9 0 Td <29> Tj +ET +Q +q 0.50196 0 0 rg +BT +164.3 337.1 Td /F1 10 Tf <0C12> Tj +9.3 0 Td <03> Tj +4.4 0 Td <09> Tj +ET +Q +q 0 0 0 rg +BT +181.4 337.1 Td /F1 10 Tf <2A0A> Tj +ET +Q +q 0.86666 0 0 rg +BT +188.7 337.1 Td /F1 10 Tf <24> Tj +7.1 0 Td <0D> Tj +2.7 0 Td <05> Tj +7.6 0 Td <1A> Tj +2.7 0 Td <070E> Tj +8.2 0 Td <1A> Tj +2.7 0 Td <022B> Tj +11.5 0 Td <0305> Tj +11.9 0 Td <02> Tj +ET +Q +q 0 0 0 rg +BT +247.6 337.1 Td /F1 10 Tf <2C> Tj +ET +Q +q 0.50196 0 0 rg +BT +250 337.1 Td /F1 10 Tf <0C12> Tj +9.3 0 Td <03> Tj +4.3 0 Td <09> Tj +ET +Q +q 0 0 0 rg +BT +267 337.1 Td /F1 10 Tf <2A> Tj +ET +Q +q 0.86666 0 0 rg +BT +271.9 337.1 Td /F1 10 Tf <2D> Tj +6 0 Td <030D> Tj +7 0 Td <0223> Tj +9.3 0 Td <070E> Tj +8.2 0 Td <1A> Tj +2.7 0 Td <022B> Tj +11.4 0 Td <0305> Tj +12 0 Td <02> Tj +ET +Q +q 0 0 0 rg +BT +332.9 337.1 Td /F1 10 Tf <2C> Tj +ET +Q +q 0.50196 0 0 rg +BT +335.3 337.1 Td /F1 10 Tf <0C1203> Tj +13.7 0 Td <09> Tj +ET +Q +q 0 0 0 rg +BT +352.3 337.1 Td /F1 10 Tf <2A0A> Tj +7.3 0 Td <2E> Tj +7.1 0 Td <23> Tj +4.8 0 Td <19> Tj +3.2 0 Td <070E> Tj +8.2 0 Td <1A> Tj +2.8 0 Td <022B> Tj +11.4 0 Td <0305> Tj +12 0 Td <022C> Tj +ET +Q +q 0.50196 0 0 rg +BT +415.8 337.1 Td /F1 10 Tf <0C080F14> Tj +18 0 Td <0D> Tj +ET +Q +q 0 0 0 rg +BT +436.6 337.1 Td /F1 10 Tf <0A> Tj +ET +Q +q 0.50196 0 0 rg +BT +439 337.1 Td /F1 10 Tf <1D> Tj +4.9 0 Td <08081A> Tj +ET +Q +q 0 0 0 rg +BT +90 326.1 Td /F1 10 Tf <2F> Tj +7.1 0 Td <2B> Tj +7.1 0 Td <2D> Tj +6 0 Td <30> Tj +7 0 Td <1E> Tj +4.9 0 Td <2E> Tj +7 0 Td <31> Tj +7 0 Td <07> Tj +5.4 0 Td <32> Tj +3.3 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 301.7 Td /F1 10 Tf <24> Tj +7.1 0 Td <0D> Tj +2.7 0 Td <05> Tj +7.6 0 Td <1A> Tj +2.8 0 Td <07> Tj +5.4 0 Td <0E> Tj +2.8 0 Td <1A> Tj +2.7 0 Td <022B> Tj +11.4 0 Td <0305> Tj +12 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <330F> Tj +8.1 0 Td <03> Tj +4.3 0 Td <05> Tj +7.7 0 Td <020A> Tj +6.7 0 Td <08> Tj +4.9 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.8 0 Td <17> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <21> Tj +4.9 0 Td <170D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <120D> Tj +7.6 0 Td <05> Tj +7.7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <020A> Tj +6.7 0 Td <22> Tj +7.1 0 Td <12020902> Tj +16.9 0 Td <0A> Tj +2.4 0 Td <120D> Tj +7.6 0 Td <05> Tj +7.6 0 Td <1A> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D1A> Tj +12 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <1D> Tj +4.9 0 Td <020A> Tj +6.7 0 Td <21> Tj +4.9 0 Td <17> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <06> Tj +2.5 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 277.4 Td /F1 10 Tf <2D> Tj +6 0 Td <030D> Tj +7 0 Td <022307> Tj +14.7 0 Td <0E> Tj +2.8 0 Td <1A> Tj +2.7 0 Td <022B> Tj +11.4 0 Td <0305> Tj +12 0 Td <020A> Tj +6.8 0 Td <33> Tj +3.2 0 Td <0F> Tj +4.9 0 Td <0305> Tj +11.9 0 Td <020A> Tj +6.7 0 Td <0819> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <170D> Tj +7.6 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <2D> Tj +5.9 0 Td <030D> Tj +7.1 0 Td <0223> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <04> Tj +4.9 0 Td <080C17> Tj +14.2 0 Td <05> Tj +7.6 0 Td <02> Tj +4.3 0 Td <0F0D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <12> Tj +4.9 0 Td <020902> Tj +12 0 Td <0A> Tj +2.4 0 Td <2D> Tj +6 0 Td <030D> Tj +7 0 Td <0223> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D1A> Tj +12 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <1D> Tj +4.9 0 Td <020A> Tj +6.7 0 Td <21> Tj +4.9 0 Td <17> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 253 Td /F1 10 Tf <2E> Tj +7.1 0 Td <23> Tj +4.8 0 Td <19> Tj +3.2 0 Td <07> Tj +5.5 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <022B> Tj +11.4 0 Td <0305> Tj +12 0 Td <020A> Tj +6.8 0 Td <26> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0F> Tj +4.9 0 Td <03> Tj +4.3 0 Td <05> Tj +7.6 0 Td <020A> Tj +6.7 0 Td <08> Tj +4.9 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <2E> Tj +7 0 Td <23> Tj +4.9 0 Td <19> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <07> Tj +5.4 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0206> Tj +ET +Q +q 0 0 0 rg +BT +90 228.7 Td /F1 10 Tf <2F> Tj +7.1 0 Td <2B> Tj +7.1 0 Td <2D> Tj +6 0 Td <30> Tj +7 0 Td <1E> Tj +4.9 0 Td <2E> Tj +7 0 Td <31> Tj +7 0 Td <07> Tj +5.4 0 Td <0A> Tj +2.4 0 Td <26> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <1A> Tj +2.7 0 Td <03> Tj +4.3 0 Td <10> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <08> Tj +5 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.7 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <1D02> Tj +9.2 0 Td <0F> Tj +4.9 0 Td <0C1205> Tj +16.9 0 Td <03> Tj +4.4 0 Td <09> Tj +3.3 0 Td <13> Tj +4.9 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <0F1A> Tj +7.6 0 Td <0B> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <12> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0423> Tj +9.8 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0214> Tj +8.1 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 204.3 Td /F1 10 Tf <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F0C120A> Tj +16.6 0 Td <0C1A> Tj +7.1 0 Td <0314> Tj +8.1 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <0C03> Tj +8.6 0 Td <0F0A> Tj +7.3 0 Td <22> Tj +7.1 0 Td <080913> Tj +13.2 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F0A> Tj +7.3 0 Td <20> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <09> Tj +3.2 0 Td <02100E> Tj +12 0 Td <05> Tj +7.6 0 Td <0206> Tj +6.9 0 Td <0A> Tj +2.4 0 Td <07> Tj +5.5 0 Td <0E> Tj +2.7 0 Td <09> Tj +3.3 0 Td <140D> Tj +6.7 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0C03> Tj +8.6 0 Td <0F0A> Tj +7.3 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.7 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <031A> Tj +7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <04> Tj +4.9 0 Td <030D> Tj +7 0 Td <03> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <14020D> Tj +10.9 0 Td <14> Tj +3.8 0 Td <2C> Tj +2.5 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.6 0 Td <0F14> Tj +8.7 0 Td <0209> Tj +7.7 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <120205> Tj +17 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0309> Tj +7.6 0 Td <09030F> Tj +12.5 0 Td <10> Tj +4.8 0 Td <0205> Tj +12 0 Td <02> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <2C> Tj +2.4 0 Td <0A> Tj +2.4 0 Td <05> Tj +7.6 0 Td <0313> Tj +9.3 0 Td <02> Tj +ET +Q +q 0 0 0 rg +BT +90 193.3 Td /F1 10 Tf <1D02> Tj +9.2 0 Td <0F> Tj +4.9 0 Td <0C1205> Tj +16.9 0 Td <0309> Tj +7.7 0 Td <13> Tj +4.9 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <1A> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <09> Tj +3.3 0 Td <021417> Tj +13 0 Td <1A> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.6 0 Td <0F0A> Tj +7.3 0 Td <0D> Tj +2.8 0 Td <031D1A> Tj +11.9 0 Td <0214> Tj +8.2 0 Td <06> Tj +2.6 0 Td <0A> Tj +2.4 0 Td <2F> Tj +7.1 0 Td <09> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.8 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <0C030F0A> Tj +16 0 Td <05> Tj +7.6 0 Td <0313> Tj +9.3 0 Td <020A> Tj +6.7 0 Td <1D02> Tj +9.2 0 Td <0F0C1205> Tj +21.8 0 Td <03> Tj +4.4 0 Td <09> Tj +3.3 0 Td <13> Tj +4.9 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.8 0 Td <0F1A> Tj +7.6 0 Td <0B> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.8 0 Td <0D> Tj +2.7 0 Td <12> Tj +5 0 Td <0A> Tj +2.4 0 Td <0423> Tj +9.8 0 Td <19> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <021406> Tj +10.7 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 168.9 Td /F2 10 Tf <1A> Tj +7.8 0 Td <19> Tj +4.9 0 Td <1B> Tj +7 0 Td <10> Tj +2.4 0 Td <0D> Tj +3.3 0 Td <1910> Tj +7.4 0 Td <14> Tj +5.5 0 Td <0A> Tj +3.8 0 Td <02> Tj +4.4 0 Td <11> Tj +ET +Q +q 1 0 0 1 90 168.9 cm +0.6 w 0 0 0 RG +0 -0.9 m 49.7 -0.9 l S +Q +q 0 0 0 rg +BT +90 144.6 Td /F1 10 Tf <27> Tj +7.1 0 Td <1A> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0B> Tj +4.9 0 Td <08> Tj +4.8 0 Td <17> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0F> Tj +4.9 0 Td <02> Tj +4.3 0 Td <02040A> Tj +11.6 0 Td <0E> Tj +2.8 0 Td <14> Tj +3.8 0 Td <1B> Tj +ET +Q +q 0 0 0 rg +BT +90 120.2 Td /F1 10 Tf <1C> Tj +4.9 0 Td <32> Tj +3.2 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +100.5 120.2 Td /F1 10 Tf <1F09> Tj +9.8 0 Td <02030D> Tj +11.4 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <1D34> Tj +7.6 0 Td <020C0D> Tj +11.6 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <0C1A> Tj +7 0 Td <0314> Tj +8.2 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <0C12> Tj +9.3 0 Td <28> Tj +2.7 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 94.1 Td /F1 10 Tf <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +ET +Q +q 0 0 0 rg +BT +115 94.1 Td /F1 12 Tf <0A> Tj +3 0 Td <1D> Tj +5.8 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <0C> Tj +5.3 0 Td <12> Tj +5.8 0 Td <29> Tj +3.9 0 Td <240D> Tj +11.7 0 Td <05> Tj +9.2 0 Td <1A> Tj +3.2 0 Td <19> Tj +4 0 Td <0E> Tj +3.3 0 Td <1A> Tj +3.3 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.9 0 Td <03> Tj +5.2 0 Td <05> Tj +9.2 0 Td <02> Tj +5.2 0 Td <2C25> Tj +10.1 0 Td <02> Tj +5.2 0 Td <23> Tj +5.9 0 Td <19> Tj +4 0 Td <0E> Tj +3.3 0 Td <1A> Tj +3.3 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.9 0 Td <03> Tj +5.2 0 Td <05> Tj +9.2 0 Td <02> Tj +5.2 0 Td <2C2E> Tj +11.5 0 Td <23> Tj +5.9 0 Td <19> Tj +4 0 Td <19> Tj +3.9 0 Td <0E> Tj +3.4 0 Td <1A> Tj +3.3 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.9 0 Td <03> Tj +5.2 0 Td <05> Tj +9.1 0 Td <02> Tj +5.3 0 Td <35> Tj +3.9 0 Td <0E> Tj +3.3 0 Td <36> Tj +3.9 0 Td <32> Tj +3.9 0 Td <28> Tj +ET +Q +Q endstream +endobj + +2 0 obj + 21407 +endobj + +3 0 obj +<< /Length 4 0 R +>> +stream +0 w +q 0 0.1 595.3 841.9 re W* n +q 0 0 0 rg +BT +90 761.1 Td /F1 10 Tf <21> Tj +4.9 0 Td <17> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <0F> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0C> Tj +4.3 0 Td <0214> Tj +8.2 0 Td <14> Tj +3.8 0 Td <03090B> Tj +12.5 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <19> Tj +3.2 0 Td <0809> Tj +8.2 0 Td <05> Tj +7.7 0 Td <030D> Tj +7 0 Td <0E> Tj +2.8 0 Td <080F> Tj +9.9 0 Td <0A> Tj +2.4 0 Td <031D08> Tj +14.1 0 Td <170D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <12030D> Tj +12 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <1D02> Tj +9.2 0 Td <0F0C1205> Tj +21.8 0 Td <0309> Tj +7.6 0 Td <13> Tj +4.9 0 Td <0204> Tj +9.4 0 Td <0A> Tj +2.4 0 Td <1D> Tj +4.9 0 Td <0B> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.9 0 Td <14> Tj +3.8 0 Td <0E> Tj +2.6 0 Td <0F10> Tj +9.7 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.2 0 Td <17> Tj +4.9 0 Td <0F> Tj +4.8 0 Td <0C0D> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <080F> Tj +ET +Q +q 0 0 0 rg +BT +372 761.1 Td /F1 10 Tf <1B> Tj +ET +Q +q 0 0 0 rg +BT +374.8 761.1 Td /F1 10 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +377.2 761.1 Td /F1 10 Tf <1302090F> Tj +17.4 0 Td <021A> Tj +7 0 Td <29> Tj +3.3 0 Td <140D> Tj +6.5 0 Td <041B> Tj +7.6 0 Td <1B> Tj +ET +Q +q 0.86666 0 0 rg +BT +421.9 761.1 Td /F1 10 Tf <14> Tj +3.8 0 Td <0D> Tj +2.8 0 Td <09> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +444.2 761.1 Td /F1 10 Tf <32> Tj +3.2 0 Td <28> Tj +ET +Q +q 0 0 0 rg +BT +90 750 Td /F1 10 Tf <150D> Tj +6 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.8 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.9 0 Td <14> Tj +3.7 0 Td <0204> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0809> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <040214> Tj +13.1 0 Td <0C> Tj +4.4 0 Td <09> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <21> Tj +5 0 Td <0D> Tj +2.7 0 Td <0E> Tj +2.8 0 Td <08> Tj +4.9 0 Td <0F14> Tj +8.8 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <2D> Tj +6 0 Td <030D> Tj +7.1 0 Td <02230A> Tj +11.6 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <12> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <05> Tj +7.7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D> Tj +9.3 0 Td <1A> Tj +2.7 0 Td <0214> Tj +8.2 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 725.4 Td /F3 10 Tf <01> Tj +5.9 0 Td <01> Tj +5.9 0 Td <01> Tj +5.9 0 Td <01> Tj +5.8 0 Td <01> Tj +5.9 0 Td <01> Tj +ET +Q +q 0 0 0 rg +BT +125.3 725.4 Td /F3 10 Tf <02> Tj +5.9 0 Td <03> Tj +5.9 0 Td <04> Tj +5.9 0 Td <05> Tj +5.9 0 Td <06> Tj +5.9 0 Td <07> Tj +5.9 0 Td <08> Tj +5.9 0 Td <03> Tj +5.9 0 Td <09> Tj +5.9 0 Td <04> Tj +5.9 0 Td <03> Tj +5.9 0 Td <0A> Tj +5.9 0 Td <0B> Tj +ET +Q +q 0.86666 0 0 rg +BT +201.8 725.4 Td /F3 10 Tf <0C> Tj +5.9 0 Td <0D> Tj +5.9 0 Td <0E> Tj +5.9 0 Td <09> Tj +5.9 0 Td <05> Tj +5.9 0 Td <0F> Tj +5.9 0 Td <0A> Tj +5.9 0 Td <10> Tj +5.9 0 Td <09> Tj +5.7 0 Td <01> Tj +5.9 0 Td <08> Tj +5.9 0 Td <03> Tj +5.9 0 Td <09> Tj +5.9 0 Td <04> Tj +5.9 0 Td <03> Tj +5.9 0 Td <0A> Tj +5.8 0 Td <01> Tj +5.8 0 Td <01> Tj +5.9 0 Td <0D> Tj +5.9 0 Td <0E> Tj +5.9 0 Td <09> Tj +5.9 0 Td <05> Tj +5.9 0 Td <0F> Tj +5.9 0 Td <0A> Tj +5.9 0 Td <10> Tj +5.9 0 Td <09> Tj +5.8 0 Td <01> Tj +5.8 0 Td <10> Tj +5.9 0 Td <09> Tj +5.9 0 Td <05> Tj +5.9 0 Td <01> Tj +5.9 0 Td <11> Tj +5.9 0 Td <09> Tj +5.9 0 Td <10> Tj +5.9 0 Td <0E> Tj +5.9 0 Td <11> Tj +5.9 0 Td <12> Tj +5.9 0 Td <0C> Tj +ET +Q +q 0 0 0 rg +BT +425.2 725.4 Td /F3 10 Tf <13> Tj +5.9 0 Td <14> Tj +ET +Q +q 0 0 0 rg +BT +90 697.6 Td /F1 12 Tf <20> Tj +5.9 0 Td <32> Tj +ET +Q +q 0 0 0 rg +BT +104.2 697.6 Td /F1 10 Tf <05> Tj +7.6 0 Td <0313> Tj +9.2 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <0B21> Tj +9.8 0 Td <020402> Tj +13.5 0 Td <19> Tj +3.3 0 Td <14> Tj +3.8 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <37> Tj +7 0 Td <0209> Tj +7.6 0 Td <0F> Tj +4.8 0 Td <021A> Tj +7.1 0 Td <0A> Tj +2.4 0 Td <2C> Tj +2.4 0 Td <0A> Tj +2.4 0 Td <25> Tj +6 0 Td <09030E> Tj +10.3 0 Td <0D> Tj +2.8 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <2C> Tj +2.4 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <04> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <27> Tj +7 0 Td <09> Tj +3.3 0 Td <0C> Tj +4.4 0 Td <1F> Tj +6.6 0 Td <08> Tj +4.9 0 Td <0F0D> Tj +7.6 0 Td <030E> Tj +7.1 0 Td <0F0209> Tj +12.6 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.8 0 Td <120205> Tj +16.9 0 Td <0A> Tj +2.4 0 Td <1A> Tj +2.8 0 Td <0E> Tj +2.7 0 Td <1302> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <21> Tj +4.9 0 Td <03090305> Tj +19.5 0 Td <020D> Tj +7.1 0 Td <02> Tj +4.4 0 Td <09> Tj +3.3 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <19> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.8 0 Td <0205> Tj +11.9 0 Td <211A> Tj +7.7 0 Td <030D> Tj +7 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <08> Tj +4.9 0 Td <0F> Tj +4.8 0 Td <02> Tj +ET +Q +q 0 0 0 rg +BT +104.2 686.1 Td /F1 10 Tf <19> Tj +3.2 0 Td <170F> Tj +9.7 0 Td <0C0D> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <08> Tj +4.9 0 Td <0F> Tj +4.9 0 Td <141B> Tj +ET +Q +q 0 0 0 rg +BT +104.2 661.7 Td /F1 10 Tf <1F> Tj +6.6 0 Td <0805> Tj +12.5 0 Td <2117> Tj +9.8 0 Td <0D> Tj +2.7 0 Td <0238> Tj +9.8 0 Td <37> Tj +7 0 Td <0209> Tj +7.6 0 Td <0F021A> Tj +12 0 Td <2C25> Tj +8.4 0 Td <09030E> Tj +10.4 0 Td <0D> Tj +2.7 0 Td <14> Tj +3.8 0 Td <2C27> Tj +9.6 0 Td <09> Tj +3.3 0 Td <0C> Tj +4.4 0 Td <1F> Tj +6.6 0 Td <080F> Tj +9.8 0 Td <0D> Tj +2.7 0 Td <030E> Tj +7.1 0 Td <0F> Tj +4.9 0 Td <020939> Tj +13.1 0 Td <29> Tj +3.2 0 Td <2E> Tj +7.1 0 Td <23> Tj +4.9 0 Td <19> Tj +3.2 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <02> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <0305> Tj +12 0 Td <0232> Tj +7.5 0 Td <28> Tj +ET +Q +q 0 0 0 rg +BT +104.2 637.4 Td /F1 10 Tf <08> Tj +4.9 0 Td <09> Tj +ET +Q +q 0 0 0 rg +BT +104.2 613 Td /F1 10 Tf <1F> Tj +6.6 0 Td <0805> Tj +12.5 0 Td <2117> Tj +9.8 0 Td <0D> Tj +2.7 0 Td <02> Tj +4.3 0 Td <1E> Tj +4.8 0 Td <0F> Tj +4.9 0 Td <08> Tj +4.8 0 Td <1E04> Tj +9.8 0 Td <2319> Tj +8.1 0 Td <38> Tj +5.5 0 Td <37> Tj +7 0 Td <0209> Tj +7.6 0 Td <0F021A> Tj +12 0 Td <2C25> Tj +8.4 0 Td <09030E> Tj +10.4 0 Td <0D> Tj +2.7 0 Td <14> Tj +3.8 0 Td <2C27> Tj +9.6 0 Td <09> Tj +3.3 0 Td <0C> Tj +4.4 0 Td <1F> Tj +6.6 0 Td <080F> Tj +9.8 0 Td <0D> Tj +2.7 0 Td <030E> Tj +7.1 0 Td <0F> Tj +4.9 0 Td <020939> Tj +13.1 0 Td <29> Tj +3.3 0 Td <32> Tj +3.2 0 Td <28> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <29> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <07> Tj +5.4 0 Td <0809> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <1D02> Tj +9.2 0 Td <0F0C1205> Tj +21.8 0 Td <0309> Tj +7.7 0 Td <13> Tj +4.9 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <22> Tj +7 0 Td <0E> Tj +2.8 0 Td <0D> Tj +2.7 0 Td <1208> Tj +9.7 0 Td <17> Tj +5 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <0423> Tj +9.8 0 Td <19> Tj +3.2 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0214> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <32> Tj +ET +Q +q 0 0 0 rg +BT +104.2 586.9 Td /F1 10 Tf <27> Tj +7.1 0 Td <19> Tj +3.2 0 Td <0D> Tj +2.7 0 Td <0209> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.8 0 Td <12030D> Tj +12 0 Td <0A> Tj +2.4 0 Td <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.2 0 Td <0A> Tj +2.4 0 Td <0C1A> Tj +7.1 0 Td <031414> Tj +12.1 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <1A> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <04> Tj +ET +Q +q 0 0 0 rg +BT +216.1 586.9 Td /F1 10 Tf <08> Tj +ET +Q +q 0 0 0 rg +BT +221 586.9 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +224 586.9 Td /F1 10 Tf <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <0F0C12> Tj +14.2 0 Td <05> Tj +7.6 0 Td <0309> Tj +7.7 0 Td <13> Tj +4.9 0 Td <14> Tj +3.9 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.7 0 Td <12> Tj +5.1 0 Td <0A> Tj +2.4 0 Td <04030D> Tj +11.9 0 Td <030A> Tj +6.8 0 Td <0D> Tj +2.6 0 Td <0B> Tj +4.9 0 Td <210214> Tj +13.1 0 Td <0A> Tj +2.4 0 Td <22> Tj +ET +Q +q 0 0 0 rg +BT +342.7 586.9 Td /F1 10 Tf <120E> Tj +7.7 0 Td <0C12> Tj +ET +Q +q 0 0 0 rg +BT +359.8 586.9 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +362.8 586.9 Td /F1 10 Tf <0B> Tj +4.9 0 Td <08> Tj +4.8 0 Td <17> Tj +ET +Q +q 0 0 0 rg +BT +377.3 586.9 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +380.3 586.9 Td /F1 10 Tf <12> Tj +ET +Q +q 0 0 0 rg +BT +385.2 586.9 Td /F1 10 Tf <033A> Tj +9.2 0 Td <020A> Tj +ET +Q +q 0 0 0 rg +BT +401.1 586.9 Td /F1 10 Tf <21> Tj +4.9 0 Td <17> Tj +4.9 0 Td <0D> Tj +ET +Q +q 0 0 0 rg +BT +413.6 586.9 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +416.6 586.9 Td /F1 10 Tf <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <0205> Tj +11.9 0 Td <21> Tj +4.9 0 Td <1A> Tj +2.8 0 Td <03> Tj +4.4 0 Td <0D> Tj +2.7 0 Td <02> Tj +ET +Q +q 0 0 0 rg +BT +104.2 575.4 Td /F1 10 Tf <21> Tj +4.9 0 Td <03090305> Tj +19.6 0 Td <020D> Tj +7 0 Td <02> Tj +4.4 0 Td <09> Tj +3.3 0 Td <14> Tj +3.9 0 Td <06> Tj +2.6 0 Td <0A> Tj +2.4 0 Td <27> Tj +7 0 Td <0F> Tj +4.9 0 Td <04> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <1A> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <0C> Tj +4.4 0 Td <0902030D> Tj +14.6 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <22> Tj +7.1 0 Td <08> Tj +5 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D1A> Tj +12 0 Td <0214> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.7 0 Td <12> Tj +5 0 Td <0A> Tj +2.4 0 Td <090214> Tj +11.4 0 Td <171A> Tj +7.6 0 Td <0D> Tj +2.7 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <29> Tj +3.2 0 Td <1A> Tj +2.7 0 Td <030D> Tj +7.1 0 Td <0223> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <040A> Tj +7.3 0 Td <12> Tj +5 0 Td <0D> Tj +2.7 0 Td <05> Tj +7.6 0 Td <1A> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D1A> Tj +12 0 Td <0214> Tj +8.1 0 Td <32> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <040A> Tj +7.3 0 Td <21> Tj +4.8 0 Td <170D> Tj +7.6 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.9 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.6 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <0214> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.7 0 Td <12> Tj +ET +Q +q 0 0 0 rg +BT +104.2 562.5 Td /F1 10 Tf <19> Tj +3.3 0 Td <0E> Tj +2.7 0 Td <1A> Tj +2.7 0 Td <020A> Tj +6.8 0 Td <0F> Tj +4.8 0 Td <0305> Tj +11.9 0 Td <0214> Tj +8.2 0 Td <0A> Tj +2.4 0 Td <22> Tj +ET +Q +q 0 0 0 rg +BT +154.1 562.5 Td /F1 10 Tf <120E> Tj +7.7 0 Td <0C12> Tj +ET +Q +q 0 0 0 rg +BT +171.1 562.5 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +174.1 562.5 Td /F1 10 Tf <0B> Tj +4.9 0 Td <08> Tj +4.8 0 Td <17> Tj +4.8 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +191 562.5 Td /F1 10 Tf <12> Tj +4.9 0 Td <033A020A> Tj +ET +Q +q 0 0 0 rg +BT +211.9 562.5 Td /F1 10 Tf <14> Tj +3.8 0 Td <020D> Tj +ET +Q +q 0 0 0 rg +BT +222.8 562.5 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +225.8 562.5 Td /F1 10 Tf <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0C080F> Tj +14.1 0 Td <140D> Tj +6.6 0 Td <0917> Tj +8.2 0 Td <0C> Tj +4.4 0 Td <0D> Tj +2.7 0 Td <08> Tj +4.9 0 Td <09> Tj +3.3 0 Td <06> Tj +2.7 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +104.2 537.7 Td /F1 10 Tf <15> Tj +3.2 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <0B08> Tj +9.7 0 Td <17> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <22> Tj +7 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <08> Tj +5 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.9 0 Td <14> Tj +3.7 0 Td <020A> Tj +6.8 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <08> Tj +4.9 0 Td <0D> Tj +2.8 0 Td <12> Tj +4.9 0 Td <0209> Tj +7.7 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.6 0 Td <0B210204> Tj +19.1 0 Td <02> Tj +4.3 0 Td <19> Tj +3.3 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <04> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <21> Tj +4.8 0 Td <17> Tj +4.9 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <09> Tj +3.2 0 Td <021417> Tj +13.1 0 Td <1A> Tj +2.7 0 Td <0D> Tj +2.7 0 Td <14> Tj +4 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <1202> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <140305> Tj +15.8 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <031D> Tj +9.2 0 Td <1A> Tj +2.8 0 Td <022C0A> Tj +9.2 0 Td <0B> Tj +4.8 0 Td <08> Tj +4.9 0 Td <17> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0C03> Tj +8.6 0 Td <0F0A> Tj +7.3 0 Td <34> Tj +2.7 0 Td <17> Tj +4.9 0 Td <14> Tj +3.8 0 Td <0D> Tj +2.8 0 Td <0A> Tj +2.4 0 Td <09022102030D> Tj +24 0 Td <0A> Tj +2.4 0 Td <031A> Tj +7.1 0 Td <1A> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <14> Tj +3.9 0 Td <0D> Tj +2.7 0 Td <0221> Tj +9.2 0 Td <14> Tj +ET +Q +q 0 0 0 rg +BT +104.2 524.9 Td /F1 10 Tf <04> Tj +4.9 0 Td <02140C> Tj +12.5 0 Td <09> Tj +3.3 0 Td <0E> Tj +2.8 0 Td <1D0204> Tj +14.3 0 Td <0A> Tj +2.4 0 Td <1D> Tj +4.9 0 Td <02> Tj +4.3 0 Td <19> Tj +3.3 0 Td <0809> Tj +8.1 0 Td <02> Tj +4.5 0 Td <0A> Tj +2.4 0 Td <34> Tj +2.6 0 Td <17> Tj +4.9 0 Td <14> Tj +3.9 0 Td <0D> Tj +2.7 0 Td <0A> Tj +2.4 0 Td <22> Tj +7.1 0 Td <0E> Tj +2.7 0 Td <0D> Tj +2.7 0 Td <12> Tj +5 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.9 0 Td <08> Tj +4.9 0 Td <0D> Tj +2.7 0 Td <120209> Tj +12.6 0 Td <0A> Tj +2.4 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <19> Tj +3.2 0 Td <0809> Tj +8.2 0 Td <05> Tj +7.6 0 Td <03> Tj +4.4 0 Td <0D> Tj +2.7 0 Td <0E> Tj +2.8 0 Td <080F> Tj +9.9 0 Td <0A> Tj +2.4 0 Td <03> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <04> Tj +4.9 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <0B21> Tj +9.7 0 Td <020402> Tj +13.6 0 Td <19> Tj +ET +Q +q 0 0 0 rg +BT +334.6 524.9 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +337.6 524.9 Td /F1 10 Tf <1D> Tj +4.9 0 Td <0B> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <17> Tj +4.8 0 Td <14> Tj +3.8 0 Td <0E> Tj +2.7 0 Td <0F> Tj +4.9 0 Td <10> Tj +4.8 0 Td <0A> Tj +2.4 0 Td <0D> Tj +2.7 0 Td <12> Tj +4.9 0 Td <020A> Tj +6.8 0 Td <14> Tj +3.8 0 Td <0305> Tj +12 0 Td <02> Tj +4.4 0 Td <0A> Tj +2.4 0 Td <11> Tj +6.5 0 Td <02> Tj +4.3 0 Td <0F> Tj +4.8 0 Td <0C12> Tj +9.3 0 Td <0A> Tj +2.4 0 Td <081D34> Tj +12.6 0 Td <020C0D> Tj +ET +Q +q 0 0 0 rg +BT +461.5 524.9 Td /F1 10 Tf <06> Tj +ET +Q +q 0 0 0 rg +BT +90 415.1 Td /F1 12 Tf <0A> Tj +ET +Q +q 0 0 0 rg +BT +93 415.1 Td /F1 12 Tf <2E> Tj +8.5 0 Td <02> Tj +5.2 0 Td <14> Tj +4.6 0 Td <0C> Tj +5.2 0 Td <09> Tj +3.9 0 Td <0E> Tj +3.3 0 Td <21> Tj +5.9 0 Td <0D> Tj +3.2 0 Td <0E> Tj +3.3 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.8 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <190A> Tj +6.9 0 Td <19> Tj +3.9 0 Td <08> Tj +5.8 0 Td <1A> Tj +3.3 0 Td <04> Tj +5.9 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <14> Tj +4.6 0 Td <1B> Tj +ET +Q +q 0 0 0 rg +BT +90 387.6 Td /F2 12 Tf <07> Tj +5.9 0 Td <08> Tj +5.2 0 Td <08> Tj +5.2 0 Td <07> Tj +5.9 0 Td <03> Tj +6.6 0 Td <0C> Tj +5.9 0 Td <02> Tj +5.2 0 Td <06> Tj +9.8 0 Td <02> Tj +5.2 0 Td <03> Tj +6.6 0 Td <0D> Tj +3.9 0 Td <0B> Tj +5.9 0 Td <0D> Tj +3.9 0 Td <08> Tj +5.2 0 Td <07> Tj +5.9 0 Td <18> Tj +3.3 0 Td <0D> Tj +3.9 0 Td <0A> Tj +4.7 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +191.2 387.6 Td /F1 12 Tf <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <1D> Tj +5.9 0 Td <02> Tj +5.1 0 Td <0F> Tj +5.9 0 Td <0C> Tj +5.1 0 Td <12> Tj +5.9 0 Td <05> Tj +9.1 0 Td <03> Tj +5.1 0 Td <09> Tj +3.9 0 Td <13> Tj +5.9 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <220E> Tj +11.8 0 Td <0D> Tj +3.2 0 Td <12> Tj +6 0 Td <0A> Tj +3 0 Td <03> Tj +5.2 0 Td <09> Tj +3.8 0 Td <09> Tj +3.9 0 Td <03> Tj +5.1 0 Td <0F> Tj +5.8 0 Td <10> Tj +5.9 0 Td <02> Tj +5.2 0 Td <05> Tj +9.2 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.9 0 Td <0D> Tj +3.2 0 Td <0A> Tj +3 0 Td <0D> Tj +3.2 0 Td <09> Tj +3.9 0 Td <03> Tj +5.2 0 Td <0E> Tj +3.3 0 Td <0D> Tj +3.3 0 Td <14> Tj +ET +Q +q 0 0 0 rg +BT +90 360.2 Td /F2 12 Tf <01> Tj +6.6 0 Td <1C> Tj +3.9 0 Td <1C> Tj +3.9 0 Td <0B> Tj +5.9 0 Td <08> Tj +5.2 0 Td <02> Tj +5.2 0 Td <07> Tj +5.9 0 Td <15> Tj +6.5 0 Td <02> Tj +5.2 0 Td <08> Tj +ET +Q +q 0 0 0 rg +BT +143.7 360.2 Td /F1 12 Tf <0A> Tj +3 0 Td <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.1 0 Td <14> Tj +4.6 0 Td <0D> Tj +3.3 0 Td <0E> Tj +3.2 0 Td <0F> Tj +5.9 0 Td <10> Tj +6 0 Td <0A> Tj +3 0 Td <21> Tj +5.8 0 Td <09> Tj +3.9 0 Td <08> Tj +5.8 0 Td <10> Tj +5.9 0 Td <09> Tj +3.9 0 Td <03> Tj +5.1 0 Td <05> Tj +9.2 0 Td <0A> Tj +3 0 Td <1908> Tj +9.7 0 Td <09> Tj +3.9 0 Td <0A> Tj +3 0 Td <02> Tj +5.2 0 Td <23> Tj +5.9 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.1 0 Td <0F> Tj +5.9 0 Td <04> Tj +5.9 0 Td <02> Tj +5.2 0 Td <04> Tj +5.9 0 Td <0A> Tj +3 0 Td <3A> Tj +5.9 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <14> Tj +4.6 0 Td <0E> Tj +3.2 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.9 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <190A> Tj +6.9 0 Td <21> Tj +5.8 0 Td <03> Tj +5.2 0 Td <09> Tj +3.8 0 Td <14> Tj +4.6 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <06> Tj +3.1 0 Td <0A> Tj +3 0 Td <15> Tj +3.9 0 Td <0D> Tj +3.1 0 Td <0A> Tj +3 0 Td <0C> Tj +5.2 0 Td <08> Tj +5.9 0 Td <17> Tj +5.8 0 Td <1A> Tj +3.3 0 Td <04> Tj +6 0 Td <0A> Tj +3 0 Td <1D> Tj +5.9 0 Td <02> Tj +5.3 0 Td <0A> Tj +3 0 Td <17> Tj +5.8 0 Td <14> Tj +4.6 0 Td <02> Tj +5.3 0 Td <19> Tj +3.9 0 Td <17> Tj +6 0 Td <1A> Tj +3.5 0 Td <0A> Tj +3 0 Td <19> Tj +3.9 0 Td <08> Tj +5.8 0 Td <09> Tj +ET +Q +q 0 0 0 rg +BT +90 346.9 Td /F1 12 Tf <0C> Tj +5.2 0 Td <09> Tj +3.9 0 Td <02> Tj +5.2 0 Td <03> Tj +5.2 0 Td <0D> Tj +3.2 0 Td <0E> Tj +3.3 0 Td <0F> Tj +5.8 0 Td <10> Tj +6 0 Td <0A> Tj +3 0 Td <08> Tj +5.9 0 Td <19> Tj +3.8 0 Td <0A> Tj +3 0 Td <0A> Tj +3 0 Td <06> Tj +3 0 Td <1D> Tj +5.8 0 Td <19> Tj +4 0 Td <19> Tj +4 0 Td <0A> Tj +3 0 Td <09> Tj +3.9 0 Td <02> Tj +5.2 0 Td <03> Tj +5.2 0 Td <04> Tj +5.9 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <06> Tj +3 0 Td <0A> Tj +3 0 Td <25> Tj +7.2 0 Td <12> Tj +5.8 0 Td <0E> Tj +3.3 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <21> Tj +5.9 0 Td <09> Tj +3.8 0 Td <08> Tj +5.9 0 Td <10> Tj +5.8 0 Td <09> Tj +3.9 0 Td <03> Tj +5.2 0 Td <05> Tj +9.1 0 Td <0A> Tj +3 0 Td <0F> Tj +5.8 0 Td <08> Tj +5.8 0 Td <0D> Tj +3.2 0 Td <0A> Tj +3 0 Td <190E> Tj +7.1 0 Td <0F> Tj +5.9 0 Td <0E> Tj +3.3 0 Td <14> Tj +4.6 0 Td <12> Tj +5.8 0 Td <02> Tj +5.3 0 Td <04> Tj +6 0 Td <0A> Tj +3 0 Td <03> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <04> Tj +5.8 0 Td <0A> Tj +3 0 Td <0E> Tj +3.3 0 Td <0D> Tj +3.3 0 Td <0A> Tj +3 0 Td <0C> Tj +5.2 0 Td <09> Tj +3.9 0 Td <02> Tj +5.2 0 Td <03> Tj +5.1 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.2 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.9 0 Td <1A> Tj +3.2 0 Td <0B> Tj +6 0 Td <0A> Tj +3 0 Td <21> Tj +5.9 0 Td <08> Tj +5.8 0 Td <1A> Tj +3.3 0 Td <0E> Tj +3.3 0 Td <10> Tj +5.9 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.8 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <03> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <04> Tj +ET +Q +q 0 0 0 rg +BT +90 333.6 Td /F1 12 Tf <0C> Tj +5.3 0 Td <0E> Tj +3.2 0 Td <09> Tj +3.8 0 Td <0C> Tj +5.3 0 Td <1A> Tj +3.3 0 Td <02> Tj +5.2 0 Td <14> Tj +4.5 0 Td <06> Tj +ET +Q +q 0 0 0 rg +BT +90 306.1 Td /F2 12 Tf <1D> Tj +8.5 0 Td <1E> Tj +5.8 0 Td <1C> Tj +4 0 Td <1F> Tj +8.5 0 Td <08> Tj +5.2 0 Td <08> Tj +5.2 0 Td <07> Tj +5.9 0 Td <20> Tj +5.9 0 Td <17> Tj +7.8 0 Td <02> Tj +5.2 0 Td <03> Tj +6.5 0 Td <04> Tj +5.2 0 Td <0506> Tj +16.4 0 Td <07> Tj +5.8 0 Td <08> Tj +5.3 0 Td <090A> Tj +ET +Q +q 0 0 0 rg +BT +202.3 306.1 Td /F1 12 Tf <0A> Tj +3 0 Td <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <1D> Tj +5.9 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <0C> Tj +5.2 0 Td <12> Tj +5.8 0 Td <05> Tj +9.1 0 Td <03> Tj +5.2 0 Td <09> Tj +3.9 0 Td <13> Tj +5.9 0 Td <14> Tj +4.5 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.9 0 Td <1A> Tj +3.2 0 Td <0B> Tj +6 0 Td <0A> Tj +3 0 Td <19> Tj +3.9 0 Td <08> Tj +5.8 0 Td <09> Tj +3.9 0 Td <0A> Tj +3 0 Td <06> Tj +2.9 0 Td <04> Tj +5.9 0 Td <23> Tj +5.9 0 Td <19> Tj +4 0 Td <0A> Tj +3 0 Td <190E> Tj +7.2 0 Td <1A> Tj +3.3 0 Td <02> Tj +5.3 0 Td <14> Tj +ET +Q +q 0 0 0 rg +BT +90 278.7 Td /F2 12 Tf <15> Tj +6.6 0 Td <1E> Tj +5.8 0 Td <1C> Tj +4 0 Td <0B> Tj +5.8 0 Td <0D> Tj +4 0 Td <19> Tj +5.9 0 Td <0B> Tj +5.9 0 Td <01> Tj +6.5 0 Td <1C> Tj +4 0 Td <1C> Tj +4.1 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +145.6 278.7 Td /F1 12 Tf <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <0C> Tj +5.2 0 Td <08> Tj +5.7 0 Td <0F> Tj +5.9 0 Td <3A> Tj +5.8 0 Td <02> Tj +5.2 0 Td <09> Tj +3.8 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <0A> Tj +3 0 Td <19> Tj +3.8 0 Td <09> Tj +3.9 0 Td <08> Tj +5.8 0 Td <05> Tj +9.2 0 Td <0A> Tj +3 0 Td <04> Tj +5.8 0 Td <23> Tj +5.9 0 Td <19> Tj +4 0 Td <0A> Tj +3 0 Td <0D> Tj +3.2 0 Td <08> Tj +5.8 0 Td <0A> Tj +3 0 Td <1D> Tj +5.8 0 Td <1919> Tj +7.9 0 Td <06> Tj +3.1 0 Td <0A> Tj +ET +Q +q 0 0 0 rg +BT +90 251.2 Td /F2 12 Tf <18> Tj +3.2 0 Td <0304> Tj +11.8 0 Td <08> Tj +5.2 0 Td <02> Tj +5.2 0 Td <0602> Tj +15 0 Td <030D> Tj +10.5 0 Td <07> Tj +5.9 0 Td <16> Tj +3.2 0 Td <10> Tj +3 0 Td <18> Tj +3.2 0 Td <030A> Tj +11.1 0 Td <02> Tj +5.2 0 Td <08> Tj +5.2 0 Td <0D> Tj +4 0 Td <18> Tj +3.2 0 Td <19> Tj +5.9 0 Td <03> Tj +ET +Q +q 0 0 0 rg +BT +197.4 251.2 Td /F1 12 Tf <0A> Tj +3 0 Td <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <0E> Tj +3.3 0 Td <0F> Tj +5.8 0 Td <0A> Tj +3 0 Td <0D> Tj +3.2 0 Td <12> Tj +5.9 0 Td <0E> Tj +3.3 0 Td <14> Tj +4.7 0 Td <0A> Tj +3 0 Td <1D> Tj +5.8 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <0C> Tj +5.3 0 Td <12> Tj +5.8 0 Td <05> Tj +9.1 0 Td <03> Tj +5.2 0 Td <09> Tj +3.9 0 Td <13> Tj +5.8 0 Td <14> Tj +4.6 0 Td <0A> Tj +3 0 Td <0E> Tj +3.2 0 Td <14> Tj +4.7 0 Td <0A> Tj +3 0 Td <17> Tj +5.9 0 Td <14> Tj +4.6 0 Td <0E> Tj +3.3 0 Td <0F> Tj +5.8 0 Td <10> Tj +6.1 0 Td <0A> Tj +3 0 Td <0E> Tj +3.2 0 Td <0F> Tj +5.9 0 Td <0C> Tj +5.1 0 Td <09> Tj +4 0 Td <02> Tj +5.2 0 Td <05> Tj +9.1 0 Td <02> Tj +5.2 0 Td <0F> Tj +5.8 0 Td <0D> Tj +3.2 0 Td <03> Tj +5.2 0 Td <1A> Tj +3.4 0 Td <0A> Tj +3 0 Td <0E> Tj +3.2 0 Td <0F> Tj +5.9 0 Td <14> Tj +4.6 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <0D> Tj +3.2 0 Td <0E> Tj +3.3 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.8 0 Td <0A> Tj +3 0 Td <1917> Tj +9.8 0 Td <0F> Tj +5.9 0 Td <0C> Tj +5.2 0 Td <0D> Tj +3.3 0 Td <0E> Tj +3.2 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.9 0 Td <060A> Tj +ET +Q +q 0 0 0 rg +BT +90 223.8 Td /F2 12 Tf <13> Tj +6.5 0 Td <07> Tj +5.9 0 Td <08> Tj +5.2 0 Td <0A> Tj +4.5 0 Td <02> Tj +5.3 0 Td <08> Tj +5.3 0 Td <10> Tj +ET +Q +q 0 0 0 rg +BT +125.7 223.8 Td /F1 12 Tf <26> Tj +5.9 0 Td <0A> Tj +3 0 Td <14> Tj +4.5 0 Td <08> Tj +5.9 0 Td <17> Tj +5.8 0 Td <09> Tj +3.9 0 Td <0C> Tj +5.2 0 Td <02> Tj +5.3 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <190A> Tj +6.9 0 Td <02> Tj +5.2 0 Td <23> Tj +5.9 0 Td <0D> Tj +3.3 0 Td <02> Tj +5.1 0 Td <0F> Tj +5.9 0 Td <04> Tj +5.9 0 Td <02> Tj +5.2 0 Td <04> Tj +6 0 Td <0A> Tj +3 0 Td <3A> Tj +5.9 0 Td <02> Tj +5.2 0 Td <09> Tj +3.8 0 Td <14> Tj +4.6 0 Td <0E> Tj +3.3 0 Td <08> Tj +5.8 0 Td <0F> Tj +5.8 0 Td <0A> Tj +3 0 Td <08> Tj +5.8 0 Td <190A> Tj +6.9 0 Td <21> Tj +5.9 0 Td <03> Tj +5.1 0 Td <09> Tj +3.9 0 Td <14> Tj +4.6 0 Td <02> Tj +5.2 0 Td <09> Tj +3.9 0 Td <06> Tj +ET +Q +Q endstream +endobj + +4 0 obj + 22923 +endobj + +6 0 obj +<< /Type /Page + /Parent 5 0 R + /MediaBox [ 0 0 595 842 ] + /Contents 1 0 R +>> +endobj + +7 0 obj +<< /Type /Page + /Parent 5 0 R + /MediaBox [ 0 0 595 842 ] + /Contents 3 0 R +>> +endobj + +8 0 obj +<< /Length 9 0 R + /Filter /FlateDecode + /Length1 44168 +>> +stream +xܼy|T?~ιw>w53w;KfMf&Ʉ@.dBl %RH\HZZ[}к.Z=h>N@yon=]=糼?z "IX'| !yՆ0C8BܑK\q6!)Zn%]u_{շT=n@hݗpPqF+P5K(/֯Zo tXq]|ʣP\q6 + oUWFI}3z?W°џJZ& Pr*FlB  +h,^HҙlEe._)֢w>a2"BLLQ\BMg,ph +$:нh6zAXBi$b?"9@ G1Ԋp&ԇ8)[퓇, j@?@/ux!@~Itn$z[p#MF'gMڧIpЏz]Q ~(bMAo=z8Fˁh1mGOwU Ev~:i$*G]Ux)s LW+*o7\C?%.[dɧ'?ՠhZ6k`V_CGi3e_W\89ym͂ w,CoiE /kv|?H?33¼R(&kNvRf[0>^Goapdi1.ΞQ6q|ⳉӓC* p zF}U?yL)03ELs;s/&3v}bbYnĕ?lQ)~EQQ5%@MC`@7= +z ~>@8}~P|7l;sU:~ A7-FH=i d ۽(y|xUffAC,;mSw7[ə?L '^ɍPzzh ؞J<k+8ԐYdz\ö/m^¶-V|Ow{"lccgwDLfDIMlN.m Y[ `"!>caD&Ŭ`ט_1b d3l]¾=+k;)=ʼr2=Og8%n~MDV?>5QRX1 'ӧ؊È)"fs7 %$#!Rǘf%/! W2;$~"bmxoz(eKޢ!kTK6uɗQb'>I~8c[pȥѥ0W\=܎˙_;GL>S†E;}h >|Kxa4Gt0[#DA _1E#Ć;I(S/Y t%p$ +2 /q%r@ޟ!؊w=$(;x#:m4x;ʒэx56PkAZ:oA_IdaÔ68?777tn= 59/hqhh0{Az{w|' aBEtu-@}]j5 #ЬڡzabC#肍}nth8r7 C:CzOkEw ]qK\_oI%Ұ52:ϵ9tkܸbڣ\ a= ;5hhU . WtD;B=OQ|H}S5JYJ% GrJ \(q\.FH C0+j30;F% +# :KeCR&5Bzi-Ŵel˹{C@ֈmD9g햦#|quauNiwjl[}Tj96åVһ`Y'?jwqxHW)G<|+ ݙ:u^(k<)4E'UreS4Rzy_nҺhАkm CBPЊ! b:Ρ޳?:;%u:7 +2P^_"?ȑW!;J~<4ȥR*^vGj|99uuSumu8TdIxF`4p}WѭAly=z~*E~G0j1"&ƀ7U !Ux06B䇩ɰM)܊ }(~<ޓz%Aɔ9vs̝uWԦk/hU6"1A*o $ p'8@Y/ s9!s(dy`2F',D +P`OvH_ULU^vV.Nu' PI}ꑓ.T68cb@Ns3?E308Wl:Ru6l +_/B!LP(*s%N$7݄@͇8y|fYE»hE$_@.`e({.g rMh$**vUa݁+JPPS_ z+["ڼѶ?س;tWn]E'Ol'E5ͦ uȽ7m͛<,dFeqvzQ}FEv[4U}w-rtޣt;-{˜fJN)lsȝʭ!~KcY˯ȇ13xU/׫mW7'99QJ9y\jR7v"HlmmՏkFU#?S(w#GiocMe6Whm6,fG'A> M>昋lV{{DDeyF;^olng짬AΪU$ڮ:bxWPg 6mhIJA2td 9i5 *St`md HCcc@:bszJP?PnTSqCJ H~h@&P uR]EY.VJ&RSj*iJ%MKA]mSQ;Jey.Aڡ2'9WiH4 ^z-)ozc|+~ZVU-LWκy3\#8wr\?,kC9b^X͂8X1'̛Цme^ֳj<©^:]>{ Aa.%D8($ɠŗH f_5ϓ)Vp('9aaFÕ2 $N%( dTھ]tjD7?$ S[&̘\?5 Ӽ!(*(A!HmQ@2-Fދiը.f/ņ ju^J2u8%or~?(כqwWKtACZLqI-:-H,m WrkM5j UC.~d)բnQQ\WWUU氖rn3Yv*m%(mV" +WM DȮO5#]RQH7.w&͗5T4^$`0Y̧ [&޺e]JLP VQ +A݁ =;8+fndoT =N fmŊŪE9nLffApdTjav":za%<(FTngiE3F?\e6$jΟɤ6(MmA;ۉxRd~Ts=Q)ͪAŠr;]4rtQ*W8AeZWxH H4* !)#QKIF#PEPx6.l|Xsï$ 2}e;+VZt) gӊ,EM谉•) Di雸-?zQѦ5B2[1bvQĩC/SZO[ĉ%k.S+u=]1*ϛ{`DeSj2S[#e?iu}m SKV [n"\/"!f*Y[bG鱃eavU$httDw|RTM}HlaHǂe{u{ uLbaOCf*N2z+6F +ECވFTFLFo] 9'9MK*WY@\t Fyz8񪺻$7=?W+. !J:,V@v.w_' uo]:ٳs >qֿY7'?NKG[ =.Qj$FHƛYN*=<*BѨ036"dx:V/:bātQbIi9.G0,$  G+ہd6jqJYR +uc%0%$Y9%6VɇCKmf[*kϚ1h4 +kTm̞!j/;/ +"+le۪ӽThahfN1JNzVʼn%EEIjYR ;àkpm^^u{gm:FF׵=%iDpߟx  ժD"Y^*gAJ2kL>sD%l +'$ZeU'rը4j*d11Fʨl@oP̘}*ɳ]iNjHOW TnW&(6He6 +$q&Y$IW.}#~h;bT))6~"QrUUN6Gι)`2HR#u:jqֳYLZ6% T+CTUkQ~֖Jĩ \.ƜjU{LW c̉1ѲhD%w :p`w`$p8p4pKKP[Bk 4\:0"BAg1ka(y4h" :ޥ;D);5jNĽ>sSĤXIԏ :O:(>Zg؍ӦMbDCC#C[wӆiqaI%הA'HڂT^PM-tz }"GBi)-LeQ2q_% -/FUDgf}^q$¡h8anXGTبSRbUeϕx/HAq>Nxo=ҳkj$#K.FɊ.5 +Y,nFTnMx+9=A[1kbEiؙmnqcm06c.qbR f#1k71j*1K^񏩏' +vUwCHwn81)eSCQV@5K.C|mGϹ~sO] >1Pgr?~ӰOkj)YzyJissR /_)bpÍ6orƢglJ곇1[6]n/ŝeG|b,[W;XVκ+;8wseX%a|_{CsP+vԮ"^EnP^:|Uح<k&YaWA^wˆa`&cXcc*Z5k r2&giqCJV_Kل&YAYbw8FFo# tA `2wkhv"k~jZQZ5@utQi`Ly۩̶̘)43Ŝ>̹=.Q*#aH W!_$qEVYE:IJ`*Bl.ഺmr@ ?@ڧoܤ#jj4r*}w5<`n(Hy bOWђ׶}.rbUhY@Rt_GWs۵OO mo9c1h TaيZl!-cf+oZr +N}qe^ٟj,a|%;&ӤIc_$f%;4aƇL*h1Mg1?Tdxy)8fYUowkbq@sQ! +L3" KR?x\k4Q8v_7YFdݺ2W.d-/2-(]Ʋ2!ay#&&»n+  jڧ UE33 FAZ χUDyĊ1т(1jxީFAyNOZrjYݠ᣺:ҧ;L-[c;".up&|z$}8}4Hp{k)&S]E +/hT7]yTh QC5A1eYb5VvwkZ[~//y`ZA=c4`/`c"V[T4u){A•"5$hɝYd N(|iퟶT+f~`61&JMC6 m&+>^YA iN@Ơ 5Gj86i̬]=&WO ʮ`R\t%ٜdL[tZt"N{s}Ҙł;w GG_8qӤ\N^ڔ܎̠m=nKmOH4Zjo +j\qOrza;>lIzrůKfx:' WWUć89QLNewc-6^Ơ鵬1*' +1Jg+R[@Եcg|YK~bL_)gψ{}a#cU+v*Jh_t0lD_ֳֶS ӓUĐ)/eUS.`0Z^ ˉ`~X)/geoRr~Sq <`_. +gIOէ//Lclw]x> =BR.&:%m& ߑ|8pRE1)&ꘫ%M)E)piiJʻ}z@4SW1\ + `OZIt/s^F`K 0^sR24c=Iɬ؝&yX^Ǧv(v8-C} +{Dp rK=|͢uCxwlZb7TLYx;jbU۴çqw޽tpmqiIA!r + uXXaZ]{H {́1Bf!Xt}Aq3I#:T*GuXuTŨV}= uU*Jd^_Wቄߗloj\7 +V2%M #.FHdůY{<}L#Z y4Aߚ*aT'ZVFp(S4: +fPqDZϺé3FXP#YȧRU vZVćd3܋D;u Q#Q6 +ss[ei9@OTQ<XMEDD,i0h6 .F܇ww1eevfseB0baQ3*-6}D iiQL]<0=^kt{oe^$C,ŀ_ R8x%SHM*c&pcS[[=O\Z\;.94Y]w3+=XxjWs'Z|!HUT+T7iA]5kR7nxLg‡/J sSQ7Wwx4JN?Q&Qv "}ׁ2)ɗ>{ EV&)i;A i?úQ< 4jj8;ERPn|$i<ޝ?'y/HW,ʽ}wEXw)z8>vh=FҚe:h21*!+qM>#JQٕد/[_ d+2s,eKfR<2 R2_^4wgVe.:X~!?q|}לz^˶le8xMO7F˒*ERs]{kMYlOsѭk6?IwiI3vvDFQ7ǵ٢S=AeT?{G|٤Tqރ=S85J؇86M=F#y9-4\!0 1WEFpSZul{Jf:H>>QMՍՏݙ^T1jGD[DǼ(j Ssk1\j +9j\B͖'⌅㿏f<igmȵ7`0WesTbX90/AKJ_vvt0y,4jرOÁ%Gv9]ǵqܧQLhCSjuS)E+uC{u}anIB~cnJs|{b\itLؤ%5e-bxAZ@2Q,Je5Uî.Ganȉ~3}wT&p~K̜ESf9nU͢pA Ύ׹y"$mfZx&R(9|.5]2` VU: ?`۾5n]I"N¡*찔ӨerI]8AzkNt?zz@")r1lwM w1CG1/XR6bo +{@)/j=(=qssJIX.S-w,s^tG ;Li3xCLJ¿9l6\ƺr99CԖ]]"v\J=" +SV?Jj5]M@f$pow]=.zɁ k?&:( HK[z,--esEr#AXPK'v +y#%* +M^ 1&NL-ȋ47n)LKJ.Tu@MT39W`a畫wED׻?l˓W[Ɗ"MO^_ Y'kHM0/2{P1+}K3J"?_o3%de˒W66&oU=}Z֙ʯ˳4Q1"}ۂB@{ԇ9c4_hӢAr*+a3٣a4 B  td0iH)PD譥bYPBTQw*]w[g ^WLӫ|DɊR=r*Wh78E^wJ0bvJmRs*J.XjME>ta}ϴT* U)p3\(uf3a8nÛmħ|ڊʮӰyE|YOP<X 5)QLbTH/U??})~Y +yoz@:_]Us8ħYM,#O9r>Qipum\ps-Mwn'/CWoo>?M{uE.)G`P\-q^ߦ]=2vlUa.|-UUDQ9üP'x҇w|bQatr$9ŰTj.YF1U*islahhP8uN+ }/ϑ~l4 sIc4/Jjp +FJK20UI9<>]`6tn~똋q8G(b^V_< Ndz"X FHdzS4z{qI#ݜ/qVgkjvSond^5/.q-;j6k7Mq]/E|7I?7qMܑ˪:jȯh>_huS8W$_ +y=VFAue\>ˈCC$=C.1.RǣxM\P(8qh-D=t\NcTdS\^?ɤ-اg.%&9<"o!:l2{W,1=@0H?t ߣ ,~'T T{BpKoӧkN^l )Gǃ($7?wٌ0n|ow6SwJvnp]8;%'A7|}Kdϒl6!8JfF\CrS7PƷ-9gʓXuw!w#[R2,+[_N./ܧxV<.>TC37dQF]ڃX4Jb/AݟAx_oHbNVwSE}Ɗi'@ˉ|.B!I[lDzWߢơAғݜ]c.da5FEx"WKzb.+M(\[}&(Vg@ɿY1SV5gM_LYDMp\DQ!X^IhPڌmr{<^gR'O +g;rHxZݾRCg+gxK^o͋c3?2.[;}k}Avaȸja~a!!e!;Ʒ7߿_*/6z߇GPU4U=|F."z&j Qd">+!>Ay=SFf`%(65 d%wGA_40ˇdXrw9)R;(*,EcݲGc[MG:FgW"ukpI|Z|. N[9x+7>?(v/tA1vǟ7o3(~ +QdӁd֓憎g(iA*<UӚ7GD٤t:̗>ɩe$گ&*_k &災}|~,C@94ҋȦ6h+vO97/ZH+UlgJ%ߦ';,zU]hg^'&ZȍJMOmm&yPmBb FH~PbuE}cn 9Կgߋ>X^}0/;yG,,}bIx|8Su'Wrz6;Ml7**R잌DZC5mRxh}/3X d` 5ֶ\uc+`ӹ3Ӊ->[Z+l<12+YkSJTz1TI2cϊs+ņ Xu-ݚf/iڬ]xR囩hϊg@WE:d`sQXM2 DPv.;v5FUft,l (.~c]>>i̥W~S N<߅.hPv +i@Kr-v : w3ZL.RL h5] Š?yM<Bu@G$T5;+>LB;%;.bK(,u0bE)PeU{?uK^Wy˪~k-koW߶,Y҇m]I-[$Qb؀cv#K KB8NHq~IJxI mhiLBCFNy~5ݶۗm_vyin +I ̜;sf9g3w^j)N~pXV'EMB]ˑ 껽PPIԯŻջK(y컆VX-kJYiާ$F2Fd0錶"%#YWF4.O#t|zhxYprrZLg̋vg; {WUejkimr3֗SUl܌ %{Y.w-_*3N)SK%nTF`Td67}sw[؝m)k)F!ʿ~ʏ+\uR|7}ŀN}^sLz\q\-}ahLiClM"zeȎ +u>VvW 2|ULUW- ?)\0ezW^"nlPY j%EMȀMT +X0Bلu 8YYd}y?޾`"n +b5y)Vørν{t:s?kn {w,rهq;{`Y b5.Rc`;w\Ɗ{+&k'_'щuʤe60 ^VWc:\5onjs$)iʖjHA郶)t×îzꢋ{HOb)cX0 ~T2Tj+*`<-ddDM[[I]2V+6ac3,*>Gwk-e@_]}3`nybI:W٫ +{[ųO$܉ E\o3Bt qC|墯 l#hnɛ{vSd=ἥvބ XZB|9w"c?2(ƚ;s=;:XIvYz+u6|705FrkHqK=j~"-ͻ{2?i9[6w=tw4|5kӘtޤvi\*ӊ:}-Rjo5tCNj`᠉[t=uM8¦##s&TZɬiGI.QK =g0l:O{#"]j]l5l2fTq]!fw3,8TDfʕ N'ecݎfZw8gy|_ +<٧rnd>lfs?7[헷zs!sc^G&AW 9 ~0zډΛ&@ǝ;"if"RH]d%ӠSd򖯤cxuZW9}1tl+']̖{JɝV!|OL1sJT o rg罛;6b74`ԱXha +KvZT)ۉ-mϴURoro6iV[oNþƟ2U k()T9_zjVl6!Xux-#wk`VZv|Jw2uY1 ULu_MAN‚v%`Pr,dlW]%-Ia +:O^ӽL=PCgs得1kx7_dU׏LL}# ++ƘòQ>00%x7D.izTfgėT|̭`^:KtN OkҞUn_ڏ:lpp1egrɃ8]SW7 \}֠Q U%>mlGֶ{EPYc4$;`ll&9Ax}u{ww#/38\C&.4ʫ Ȋrr ɣ[?C6na:|}]Gatw97 t 6z?(.Ԗ//onvq% wFdv 6`Ss,FdYfX3)KaG xRae_BfQ3d+TZ(:WJERiyֻjVwS[[}}:XLjeDE.49fЧS2SJ<99Ufc3]/c/or%ϗ, ڛW. CgK2b +’-`Yvr&i5dSpC-ǧ."s- 2@0Ѓ'Z*W" +bȫ8!޽mKZrY+Ut8Fmilhp֗\ʩXuZmm3~5׳+^ %QV]a!/)} ZA:+]tIkVW [+K%,#3RĊa;b;,ۘb86u>1n{IS3'fqxf"テ h ӏX;_9RI.H! 0;[]Nrޱ]tTtn^w^ %Ds$ a|і\,w6DqV4HkR*$UH@B% $ 0nqU >(NfN|mIÐ#jHF^F!yC}^$9G0JbBE>;A@|*،?=@b^y}=8'+joױ:zSL:@YKTobNStMQ©EצE-Ttitiٓ/2Lc#gu^(?85E4-fzʎfۗ~u=]uuo~q1}>]eʼd=⇊mfEczÊ}:UN˔hiTN8j'}rt.T.Wzz&E=Š?J+*fH+Ŵ +>U>%d>.'rHοq w-Za 30$; ˓)3/ "iUIS*!\᭜I;+]Vba{G9teK6 o- ï/) \̖O%W111:'\2ude]}k?R;[{f,vŕ0ʕUErU**^N\\C*d:ʳF(d^*q!]1Nju-Ohoă+śZ - B "%\VY4k*k |%@1[B@B5׽@ \_+-_mE+t3'jHiH?qʯ:u%*q3+A@YR@d5Z#ˢv^Rց~VYG ,.|hZoʷWW<]vN^׿hxjs~cz|5gm}u?\bXCMMO;.QB۠?#?׉`R"7ˆhײseKSJg7U\KH=Z.Gdpx3{^F>WJ^"tzۼ=UpT- iqS#"yPŨ1ihPRh) +9MR jz6 V_C+ u(.Mpe隸H7(#3:? #td(pБ.#UZtT#ࠣ +8\'#:2_pQ,^ *4(^Hy(Jq5Kj5 R)^FS兩}JVEiSH)^CNJ&eIzFRp{W!I\S1!7uxm(@;Tajnr5:_nDhMӔ(L +rHZ\!d3Op#:]N4FSrK9iBA*V-iJ&yK(S -}[GXJ-LѶP'H(B.jÔooyNca^z0ngDhM*oEi{MY'9osW/^렖u|.y9Ą|y Q֝sкeѼHi,Who2sd5}$,JShMՍQ=rBGj,i?[<kU Ҿ.:ЏD)wB3s1c48}fP8eBIAFav+/!"Q{( }u~ H 1%}hWf9h_[/Au22D%A4з 2 k,H8)87M{J!719?F:S-qj"'.Z5anC^%g =HxKf?kaD_%HƝkG|آ !Hyrgx삮"y~^ewf{pq/ϷZ'P/"4f-/$$I3=ưc{॒ǒkڒ#B@r:_8&ҿM#1e]zZ:'{(A%zsN|?>\w Ev0/hIEiO_/?^- +}ehtJ?6_=.Vc7]jCUuVs٥ՆiTtJ 9\.$%dP~>?Mt鸘Z=kWzovAזobH'Y?o& V`% `L܆zJ.fo5D+Mo1Jzd"<Xĭ'd ǸD4:_!r̸x4CBR\w -x\M?6EF)nS8N"1 AbT"'(ab,"in"BTd498;͍AH*3 +In8x,L#'7R`0Jd5. S 7Tm4 D_7A \& +'B0ITÓW0_?a(gF@/\t8C%D%q*hw1nw ]J +vpA2I \*FD9R$6>JBitLh$I*[ڗ\T42,ґvJ}2<:3H9/q0ITx3$ *ʑV]&NƄ$)qj,ƚ Bl:dک |-( |AǤbgKYOm8 m~Tl+[e+\.\~[-knuy+׺Q*>}dc$WN=aL, I]0t⒏ 7اS?^bϰ'nBe?>FYKpMi ''nq&lK a66XvDw(\>FiIw? & }:a} @rC"ړ4{f= Rd+j@):)'{0b'@~F6:ϲ# j;2rX+!_$*BYy! xv A4t`i8e,9|eXWڶlZ+i[~pL yE%'!IH$%%rfGA`Up_A_(Ňd+jAx9N!N_\Wj __ W*S +BUP.b%14"%.{`p \ajǹ|$-/Pwϐõz>38f2d -qk?"Z{mGDvkiqZ6bm#O?{׳d/ZrSl%YݪĜ ; Tq1s>C`@ '] F!O8xfI< ?m[_4 yNp/^0 'TF|: n6hP;@@^e7 wp "vma0 S.+3r>42_-(1>AmnoQr(al0)!|~ ~e_YWBnȄLu%oSw#u}&&Mߙ_4)w7HJhJŏS +o[Vү`(uPw_Pu,~uBN871zJ/r xz3thּip\^s_ȋ%뽟?" tӸQHtqJBqJ} +5R?m|B6(xV]Yo_GQ ChN %weINR^,p2>Z1kBE%P J"+~EM㟼gI*W/C6?|+k|q[O`9kfޜ5oAĹ9h<BZ6l5>oG, 6`f| +Y/68x3D6l\}θ:!%_R,IWj+.(BY ӂ8k[˥MRNZ%42HV(Sd2L$cdHFΕRxqEW3rt{b3S0=xFӃz:fZ=s+fV{fd}o=jyx`$!ÌOO ➙A3꡸uیҡE۵횛=k:EGhlyWgR53cK.& ֗=̮M$98OLȐxl 2YJ:O<7p7!%" >Sjh^5L5!{3S-άaLUhf +$VBr +4hggYi9VeY6M]H')qN:-uW΁mߵ~lr_pr}bͺijS(e>9$M=Z;Q?i =© QB""2F +endstream +endobj + +9 0 obj +27139 +endobj + +10 0 obj +<< /Type /FontDescriptor + /FontName /BAAAAA+TimesNewRomanPSMT + /Flags 4 + /FontBBox [ -568 -306 2027 1006 ] + /ItalicAngle 0 + /Ascent 891 + /Descent -216 + /CapHeight 1006 + /StemV 80 + /FontFile2 8 0 R +>> +endobj + +11 0 obj +<< /Length 487 + /Filter /FlateDecode >> +stream +x]M0Hxl +EHd#5@Irȿ/wU3$z&Je?i '΅_ӯ푏qO*OV;/{~moթ χnOctJ@vmlZqiZ:M_-V:MX ,`a(*aNx `qqa{9}V +Os4},чѧBC4} sSTӧc64Qӧdm)M>aB +TMSANc )7Y|$:# 7 +B^ }BKr>k}9>n B OÕr } 6J_#9}=y0ez>0"/XUendstream +endobj + +12 0 obj +<< /Type /Font + /Subtype /TrueType + /BaseFont /BAAAAA+TimesNewRomanPSMT + /FirstChar 0 + /LastChar 58 + /Widths [ 777 666 443 443 500 777 250 556 + 500 333 250 500 443 277 277 500 + 500 666 500 500 389 333 180 500 + 500 333 277 277 500 500 500 666 + 500 500 722 500 722 610 500 722 + 277 333 500 722 250 610 722 722 + 722 722 333 333 277 333 333 722 + 563 563 500 ] + /FontDescriptor 10 0 R + /ToUnicode 11 0 R +>> +endobj + +13 0 obj +<< /Length 14 0 R + /Filter /FlateDecode + /Length1 36604 +>> +stream +xy|ř0\=sܗf4Ӳղ,Y>d 06KƖ,ɒl#! g8!XH`dA $ vNLȇěI &Hzn2}}?4|!#ڏX$usGu qW|!v?y!l]CRP;ufZ裢 +͌h ? h+U_ݐ|ȃWXb_ǎ\[)Üʾ{b_^dٷ^Wn;*OzE\6 3Xmjt͇96[`mO< u}4O2!I;{ ֗@&1S7UF݄ .|+>h +qS\.v J +t Eq,K=̧}Q|۳U!euQX^M;i*ou*n@_EлXu؈XeVvĿbLnao +]nDOh +eZV|?g/a/cTI;U_W}Wڪ̏fNI?Ũ>mh+ s~f_/Q>ofo%΢i4k#Ͻ(Ҏs@[s߂}_???o&Ĥzf9ify>y5Wg&Fvi;>*W5^PVެ^ެTߪ+M}F==Mpk +Mf4Ok~&Z` RU9g Xaӄ`]h33>|Co0`TŠ^BB/r_G/0>ϳ̷{`nTZga@56Q ?>8mb^_gϬN>dF(+av] W9|Q}z>7[Ufz)Sy\ P`` 7Wٿkp=~TbA5 k * +.:f&iyfřeazStSͽhcw"zԌ'{8 X t/:b(~̲?Pvt] ^)g!vA +T -'(8f"i{Ix5vgA{ywu3SPqWQ3tI+åMSCGՏw] R{P,X w.~ f 6> p (9\ny*ؐ@`_NA;a|- +] TBvCI +B_W10ѳw94,W^:џ,?f'Aؗ(Xץ Bv 3 +jo0fV1=3 \,bfauL#'^gjQ$-Y\<[VZRIx, D!۬l2:SXHS8oU#)t@AǂQί3*j5%5%4_b-MqߗE fYd8:E + Pe(nGvwhl_=f7DrTzLoШ;2v/`܍51HkI"Gedlk T(nlE$0\è#ՠ[NJ&6-IcW lF25 .u=9m n^h${ 6,|"ƍebM`.a4ƍF0HVBV%/i$%WH+ځ4‘И'=|u":dcDz#^I$Uo٢FB 7B:V]8YLfY 1*v0 XSrU@gTZvEzFu RNڏc|D<.Ly~IRw ̳8HzEz9ZN~ #ȓ߫]ßmEuCTR10REv}ID$˜=͍bk"7fk + o`5`Xx!>Òg+[UNjlk@*h-(8\0Z0Y)0+xo&񸘗V~?yodm;b?;9 ݸG[K&kj3|`2IU  7MM%Y3_[JFR_LeRǢq/p 0zdGxL +i Kk!I&^۰A\ wjV?}RN{٧ڧ'ݩ+6m#Vq\$Oh"l"OcrVTCA$쾭/]zw}a>Yo(H,]^==wO+r^`3gE[k5Ξaqr9ΜgġoE돘'M'bbs-zv+ _duP;Z.VԲ6B5 :aC%yYWQZ@s +YJk9euêX`x=PAƋ$Fsyo곞$wEtۙ5|{dT2 > L_ 5`ŝAk0n˳ As8h "^ے@0\nBJ7!Y"^58!s:ٶYݦƎ-U#'~?z+sFEݧz/juߵ}w_Rm/hodT7jSTzVZb +sg>ɕY̰qM +f>'X*,̫5 +HX̑H^T IDd$EŬnU*o?1}BZ)#^a]Buiq6!5.:rT]@yD%%S%! +G! + +, dR)&H1)iI9Y8@S脦Mr +8W,H.L$ |'38K+k4͔Tٸh͵YUv&k[xP |Rk)3\؇< vNBFRdy3 T0P'ҁ:]&ȹy-: J!G@K 1Pchg;+vwpʊrk6NP5߰+|bLے+3E^kb ȚU|\jbN|x6tՌ + +8Wd1rf]GuxEN_31Kmnn`.7pL0O9|/xzcբv J6s}}S5]u^oY7aQ2)ZO)gP&Ϭ*ς<3iFbBaT$0_َ53~ ɲd #a]T0QGH)lUi¡lk;DDt v_;_;\;Z;_;\;\;vlc~vl'BlLc!=f249N+rV7mZ۴"tf4IZ$&'R7/MaR YCل7uNe9^ m;϶AtNX$8$KphNDCsl&l&l&lG$Ju n߸ᚂ3R͖.ĩ ]7c;/<(T8cTGc!npF3f$}RkZ$MFڗB>#\j#aKTG"RBb9dDZ+"Ҩh©[UzJE ],6] gQfU3[,^m{ xo…{4DJ.ķNaՌ;ϸ1?\ZfxZ%եRwh+gXU~JPO:z9u)]QҾҽ|{ Xܣ7ZҺվd}jͳպdx۬e6'ELjEɢXeOe-eה}-{?2@.[І9..Үޢ_W:֯вBz,ؚY̔ޅ2#$9y֣9yx$301XLQ]hYA%&B]nYJA:^)%0Ғ%̒G'oͯcU j)Q3jIݪnWU{&pɍs'γ;i6HD1ωO=B#>h#r"`˵|-)7uU5y=Ϫ,@<3īfQq8RVg +b}*բy:Ev5hCd@\d2FlE\aqí PzoA*VNUVʬ[n)З_nm;L>tME7Uzஞۿ˯,/ Io #_gP,(5I/ɒtPN\li*%,w%NYQ|. D"Q"R7βl2P -mHތTx4'45f?%P-wa$,7/Tr\0cLk.gDS~ln˞L¿-ׅ?e6Q97ىSET;t8E1ff4Z}}Xװrs:v\U,(꽌ՕS <L㇤>ɼդ|x^8T]l2 X>N˝|c-'ycayg˷Q(.-> 3 zAл܂ *Dadt)DH$Rґ$j +АX.9/)-fkFzg,p)>_DSbf_1.3\ǿ00^ |dFX2'GQl(fG6]P&v)'MOjl`m$3/bl0Xr.Lf) ޡ>%3ٵ,YJ@¾#|?U0gڒ TrCik\1gv;${DaH]Ӓz]ǡB4nH:6SrڃR0gCdvCdr7  -u_r +5H:iEZR>!٠:AvU< )ĿI=%KF[2T#ZdX +ĸRa/Kr?tRщMa-̓Θ ՝s7@GGJ9̤ +4–SL"2qrV +V>=c>o /!xۚϮoBN}xqm=_~a3vWFނn]BC)nEM˯Hb <;5ӤϼX䓌>5V6&9eZJِ3dW-3M Oh1Z.K]QfݧSw<:+8~'2LWUs5jm+UBptn0Hѥ!SGl&XR`? H%R<]BvK$'[6Ov9lu*2`Ny%we4}tsي͸St\S0xP 9a9h)a~=bRa)9ēB yV6kZ ϴ[!zB^N[˜yGFxCx,q&xэWY{?Ṛ^ t&;Y,2hg5%+- m-S0r9g-8K-vŁc5\M)&H}:wVA-y#_pЯ\(}'UOxmESiڢ  }j3+:9cV@mc^g zFmy?.CSd* t F+ՒWg21Nc8c!xn[(lQNLVY;Q$beʳ>V_(z}?-/?#Oo/zLљ3pˮ=ۿ&/\͔ۥ#@ݨzm,i+l BW,leVl9;-_œ in_H>`!AB(IE5ETH̫Ӌ&[83k8b2,~)RwZ~@?Wm{EM x7/莃*!I|GeoAykzQjQg6Sl1cle&L'fV|`(Cd8^[9{1*hQ^}mjlV.  +pJI-ΒT*sZr).JZKJT%WhU*6JVQmw_k/a%ku|_["W-Q,m/l>lQ/d<OĊ< BTK%p~^^⹍<ᢨT<!>Ͼ"հcw pud /yȝ< }ѣoEm˜z<Bg?䬨\p јq7M~IБ^?]Rbm_hi(\"K36g=rvVbW5E^=*aFa|1:=5z"~cqQUm7kyy5oid0eC$]Pv) ``u$"eBDͩޜΠMs!Px# T@D>D(DDpրqA19,GDTZRU }AT Xz*$Q,DGL&:eB UCf\f1y|̚@9|vj\C"дdWX9dgDņVT,RnhU%{?ȯ"ǜQ뻦uEu!훾&hgS̵@FtA{ݦGLLOT6[ R:!E#h pD%\6yѨ5xu t5>-Dx +%lŽ†ЗCFz̉ 39a2=G2> ^{UȖbߓsSȝߝzIX$px~ pXOBD1k(& gL@hf2 vE +J>t뾢\_/zȼrT3^(z)%­ᐺ|e䏞Eiڰ1MUZ4޽E:cқWnD&roX^v8B*K_]ocvW p:/~G`SU WؙH5CeDs,g^iǯڳrqv12@96NcQ/^ܲ1shҊ.jq-Gl!MńhEMPX-p[D)dtЌT#30en| 4p5ߪa/͖k@aԤ_H7ٜߤEo~R͔G8 X}9N^CxDP}K{&V|~`/7 Il:x%cQ X0 FUI  ky[Qp^hõL-LI5[ hRwVMq889xQكZi<NjAzol[dۼV]sgf36S>ŠāJ(swJNrj t̨ yFH6 'k#}k2mȕՙ@FnNWlL2Wö7oDŽ01qis/M$TȯJݕ fϋNkܾlgo˗׮)f8Vf+⭑^♗t3Ѩeϫ;h+ZUۗ6 o5OW9XY8tܨ.`B="5wM 'fC@ynm@:.գk(bňC dOvJ!&lqf7^+Yy Y͌ +#p4#gxuZ סNKQ-OOǹRJG㚃;@z}-Sm3<tZy]fn ڞOgECqQJB>JJ\ϝ',ˮ UW,^qy#O;~)^2=_+8&;aiσ`OUG@ͮ['g)ɋ ߴ;D+M;M +|Wӷ'?*TkBMm66ݙG#&)c2f̜%8y*A0G3M3&y&3]W(MFq&2(J@VK +Z :Ss>dh/9]N KZLl 3d1M,KCI>fxFPꂶOh)Ami]s$wfm:IKJ] PW%q.F9?q%w,*Y5f͕4v_myt1Zϯ3O||F&܎w-1zcӫfޯ]f7w) _d~gy-jZiw ;!.u/)CiB3;WTC(~ 5$EU]U_*ZGQAhtC(: ^BL5Jף$f%G/ +] +2Z +o)M{F7ka.5]o^ ,gئ]op9|}Gj}cOHWB-c$DeP= (#ܬڋ|,HXJE7zBO(0 ֠}~~:tW֫׳؀?W`#ڪkV` +lF[icd.V`EVV!&V#^kP[ +Ev[Pm뙯>T,2L&،Ҟa&XEnX$PnT`*vRrV +k]hPn*T}:B__H~Ab?@_+ + Ay͍ }V`oG + -zS + *mIPi2Ea#YKr(l&<*T<~~Ea;y]E^ +;|SBa';R`chC<@j.p'u|RRXV`R_W@UH ~ve&H7(jR04+OI9O\i&/R%g&΢uh ڊ:P'"u-AVjr{h Jz}eSf~f"]u6<^ O1J)P)-^mi !7r A;h@釲)Csv|64:2*E?\{Ԃ5IGhH edt4QDȓ:J\E1i/80VJ_2C.ѹw+?bN2/ødNPwQ&YmGa:^(Q0HWEz-0-j?>&«e^ݴ9,w-gq~vcbOk!O;>ǹsZHq|QLAAйvBL%.'>:B!"NRg$x Nd[!׻k">R6j(:hۮh?Dǖ9K.?慄GBkc>%[aG}LˈfEhJ]ng"2v2cL\*cSh<}PdEq(eE1,]EzzAQGQ0As^J9>zl)۔B> ;(f{-\TxqNo[0.]Ӳ=B||{/ǘZ:\sr9`N睫uez8{~=rEKj@s|G+:+?L9[({vC V#[NJվ`>3Y_?[By2'dNŹ>LG[ +[Qrm(EGZV;r;:[Zܶ`Kb\\"ݺ5-vuޡܞn Կmc{daQN\6رoiI wF`=C}EAqu`WoP[VgBܱ7'skа10PH,K^8qu_/ghc 7X$nttv=➎!+7Գ/וb7 2۹ ;"nuȉ}9AĞޮ!qG?L`hWggnhh^:5s0Gq8Ҷu]=,qAו 0\'%Ė0>y0>贏@u]ܕù9XdP~2U@݄[w BAss9|`C~?L0%vwuC]Ceknp 7JkoGpйGF3p|* i;;;-69$n%ӧc8/n#]ٙ% 3<J{zm0#0Kzr@]C2l>D'c[ޞܐ9a߹K^";Ou vȅ]s=dၚLfϞ= +":rHx|mCڅ"R|/h*A!c*vT4X~A)}0+}F2%@s4tTTxaT^RaѴx~g!dKzo +Achw> T?2*!GR꿍DY͘c o]XiScY=0_CH~2-|~+P+*B)^32_XZgfU؝`y>V*OL%q1Y 9,ϰ}(db\g*=Tod'`4AG0ώ"'׍9ɧ?j^`ƴe$7K'ut#`tRTgoC@o  @oҼy f˦ɰUtˑ11 +DKװW&wJ?53]=fjWͥuϰ/qit)=~c:#*p/3~:k)F Y,ZpTPma fKivmb\&<6қ)ǜa:\4 +d-fK ^05U5Ok׌ x@ӘNfq VLiʹ8[8p +5tIe b,2!q,Ŗiv!BP!Kz)%Tf!@ +KPpC`Fhz@Xa?&!A)|kF!bw"Gf+i-B#}hcZ*FD(325I:˓0˓t'I:I ˴PeZeG*kxBĭ@\L H=n~ (q~@,@` {E'{ ! IPNh2n0BBҎ!7;3ԽglԔsIs:Ak!B(tֱG!>MϷL!RO0^ {0{td`)b(^[ZBʅmY][ Rn;T-ТAmJIܵ /%$"ܝXhBT AofO +I|q~}3{;/[Qr'gԓN3 `ơeπg|J7}Yا+Q +P!GR,@5?9VZC!Ր#5r@TG(*JF((Y%+ܕ"Ur]!F7Y|!#$!D@' _؆֓zr^,4$nR/0CTͬ fV;|fmìQ2C]ؙP2ǙL]L_J=7[̮*̮" 0א* ~t|x!t3YwcL2m0fv!f+64RfzY6f=,0@?3𡛰6E' ݉ǘŗd9wBp2?n<Ǯc 34+( F%L;+p>"\5w0(Q; #!9If:W1=B%[bf̓1kgOV`{Ke| MhJꠈ'z@A= 9v}N0c'a _x/yw:BCz%ݦu4& ڛ}v7KA!e=a +q. hd 0_#T[.'\nwA  s_pa:X+er*!é!#;Ü5]82x/_(~gXc!19߀6 +endstream +endobj + +14 0 obj +20303 +endobj + +15 0 obj +<< /Type /FontDescriptor + /FontName /CAAAAA+TimesNewRomanPS-BoldMT + /Flags 4 + /FontBBox [ -558 -306 2032 1025 ] + /ItalicAngle 0 + /Ascent 891 + /Descent -216 + /CapHeight 1025 + /StemV 80 + /FontFile2 13 0 R +>> +endobj + +16 0 obj +<< /Length 372 + /Filter /FlateDecode >> +stream +x]n@$, &DQp$e #.xct\f㥧TlSdҩKeJ+n QgVutʪ_QxC}:OҨuއ[g{5ۖYjKgq)b:NR.c}kQrȨ~>I[Q4V4ڼ9S.V/Wnl=d~$#%`A8B$a lfd2n;HL @!h@@p O40ՓѓO +OM&Z'ąhPГOO}f|Sn0&S8Ynuu?endstream +endobj + +17 0 obj +<< /Type /Font + /Subtype /TrueType + /BaseFont /CAAAAA+TimesNewRomanPS-BoldMT + /FirstChar 0 + /LastChar 32 + /Widths [ 777 556 443 556 443 556 833 500 + 443 556 389 500 500 333 250 722 + 250 333 389 556 556 556 277 666 + 277 500 777 722 333 722 500 722 + 500 ] + /FontDescriptor 15 0 R + /ToUnicode 16 0 R +>> +endobj + +18 0 obj +<< /Length 19 0 R + /Filter /FlateDecode + /Length1 22872 +>> +stream +x|y|Ǖ[O MF'$$!F8HFHI3Bv v 'fccc` p؎ر],7,v1W5 ׻}V^zU]U4 +  v>oAx;Ŵ{k6mNْͽۺH| s}"@v/1{cAuRbE;)b=QEWuv_< # +F>0 X |OrZxA&W(UjM6Q7MfG퐄e +)R}x{t<B&)M!^B'>|qs/G7C#kXnx>(X ;^`7W{QoI\ 8J 6xGSc7^MI+NǤ{Sx-,I خ؞}Y+a5pr~nw,vԌ_?fRI^\Ohtnlql{[L]5X\oQx?_QJqV %+8+J&(2 \K,_nҸ.x-k呫N` 9d<v1őg~~ '_'#=,C ycL7VS +2.#e`>#WqC~aO_Fo/>rႊe%EsxgggefyRݢ+eVraY-fѠ%j4jR! Y# O"Q[psE*;\SٙIzH]:@r|k"p\hY\RXTcv>s 99 'B"IS'&jԩT\wzz;5tEj +)/#=сL܂";+h4UjyAc>|p p~qh\O9+j6To󙓒eJR2$)gxw5נj&T2$3S uVb*YӬ3&=h޳֖SGt]۷M376}{KMvʮep|˕׍:Y?L `P=Zl[UZbrxnۙsLE%Z#67d[gnmqH -owe~ɝř6;w|z2ÜWre#٦owBs@'h˕-{]d븋s9s (f]+c7nirxH9pcٳ0Hh$V[KK *%T(k ̌4t>?B`Oyo>*` ؃ ;7y^{`+= Rv Q$oh@ÅG"Anɼ  yf9Ғhc~?PlydktI 92~$D6x>U$Gըbfx&Er<8^,7r{$SƬiYYi^M)D:-ru(h:' +N|{9NRЊ7>{TpoÍILD19~ &0/9jqԉ&Od1Kq:\/9~5ɡ0yET6#nH+j,ߵ:UB^┲fBRh`HJ"F1=w8VnJ,.Tghg=eo;3eIIr(:skef's2[Im2j,4T*4=^:ɿ8Bdh&xFMs d㟷ǧxpvsEC ;Ezԙre?Ke;*/R8vC%4/Zkms'o% +Yͻvy[wuĤTvJJ戞zR4j<.!%[ Wlsgd8'e +]BmSCv8lghlƤ#"s$d(LPh0ÑG0+!Ֆlggɨ78y+3~Qp.3}̈76Γ;k}2`]Jliu*GӞTu.T|37nX %nU߅FS@<$vTϱ;Wo6SUL`Mve&qcΧɣdpLhi4ctԏXZ<Ŧ/Wm髟Q_~;_]W0r9ZV %CV.JJ|eBJKaWSMr[Rݖ\H#iubZ[L$VYtCf/w蔪rNnvJlAT +zκBOo4r?N:Nu&A.K7 fLuM),h]bIVK.%SU)?╾ݵ{+PcvSa.[Vmy&NFia#*t=g(]B4ܚ|v]}OR<|y8s5qلp2ogޞG=W ۉ3=_gl0/sT9n=1 sQ+*7sr,}z,mЂ(}ZkMݕF&'ܧJv[[NۃQ2m `k7Ɔ9J/0\=uA!(bÓ'P;wSNڑIB +bVJZJ3V0DF&uڤ*kظcG~Q;[qaӛ v=+o*Sۍ9㧨ɏ UuD=v}p;I_IDLTR\Z5ĻN|^FnS== dgQ +BJf@1 c!<-MQNFa<33<$cɲ1gә +z>^a9TS3I8U.P'%Ľ i%a`4GB:9B^dW5ϗzVO0C#\WKZAu7)oi>>TC>hL⌗A <&>V/N.Wӛ7vч3E\5&UPeX- JNδtKWTzSCQC.nқ(-(ru +KB)yt x|]#y1䍑}n(W)s7lJ )κ&OyKbHV$N[U4O܌Y)z 01̘ᵷƌWd:J=%iAo':X6+}Ӡ9n}ǎx(ொp軧U7ܲ'k~ ە-MFsO+WE_Sw<{gNqZe⊬djɷ)jNt2%٤LRodH_b&z^xrPI2~iCW ;k+p ˣ\+Qv<^vxR+R smza&Cء8SETc4F*?pB-*}W|~W/ę8z%󰞤JVr,d+a+!`$sj.{B5+, %+`GVMp{L@͕`R !W[)J #,Dw%Xߓ`%g$X4`5%$Xt/WI_'B-T &eT#& fsdL :2K0`ԑ9(#I FOK0W FYL:`ԑeudBQGvI0\3XMе +'Phcp"= D1&b|fF` r[[ v# Nb4qf1b?28? >\"/~M8w ,46t:LMB?D%B5ֆ=BDL/C#Or&jlIb)H +{b +lF¬*/ibxZÉFE^٘C8J 'xi@l=CKFI]_Jhs2Svb[5""ʥy 3ESzS*xƸ8*q9K>x#]^6~ j_Jmb6cX]wuQYH.i!Fxa_Sd~C8n'>Ca&$"Q'x~f][Z[MFdX?]AߤDL"AxEo'Zt4./<*%0N_sjKq.- ˧d2F2 1Ì /<%;7d׍)t"Uö~6Ƅҙc7MFqnZFl,x::&ߝkYJ60mЈ>mm)Zk+b^e OWj̩--U˾&IubNb0 ~vPoe6`A6QAmE۷2 1&l%3(|GlYcwdcjiK)[j̧\KF2٪fJ*w.g[ 3핤bt<?}"]4s'G?hIEÎsQ~65/ ;"Or&m|}VR>)N̩&[hFԚSAiס1bkuZC\qcJ/Zє},ekXsTtAGXܞ =52]_^ݑiqhbOR_*ic&ƻXqiWf1 |I?ИYw3tHgv6sO`\gR<Rļk.a*zCZg8eK`.&kI&:lmHor?l6wGĦ%VCpO_kaCOW{)&$.~eeU⪞ᐸ* + m tVzCȪ^5 +Iz:`W8{i$+V74IGŦ!g?-1 {BPS;Ca?-a*7W<޶$8po`&܏!/RґPd +K5 P@ĪΡX7L{;dCDQFDz;N6G 2FTS ]l}@[A1Ї3 'CV8#TeHeJ :3@4;?22'.#ؗ $G`$|^#^XMKVW5-m\.6։-]VZvyVU7uҘ2(00@=oq TCۂôgGp+Neޞ@?7Tyb vo vjRT3Vv=8ؐ3 +&v B%d)uqhd~ڂ2CLLbs5֭a{/ +{k{[<[Ir4ttu^r;;{] xCCL8_Bz{zqdtBqbɐAtޞP7NJϿMDQUۨ$4s"&]So!6 ~iCߌ8Da6p)j2Ѓ1/1J7Fd ';S: K\w]zXd큉h ϧkVWbViQIXRX[PTPRGdAaaQ%sKĒyeeZxW:#K1?ċR]1葐^-n;[p#۴&VM^Q ^~?So^}2훗i˴o^}2훗i߼Le7/Ӿy˴'_͸L~F]'0>?c^z^fBP( ͘/e9{&<0> &~ǎGa1젥FQʪ|8 `zӫ؄v à JL{k^D1Gs1Gs1i4N}#mUN0q]Ʊ7J& X[].] +>U|>lg![ }|[cRUL( +S_C&0p엃| 9|.Xnf0c)J)XpFS\*wV`j4iwpTfUcjĴ vLcz*-> WU\#/ugʹexQLp?&YFq5&M'aziLT(LF&.0g2*9S FϤ.LF,da- d!mbOcNXھmIm̘SqXm> aSG9n KJPy j!u|l(n$&l|2'7>">A>[] c^nSqx{m?Y|XqƵ`b@4*='ВqrϹA{f {6hڠmޠ]A[AA;F}6^nvW;ϫ-jz^muCX>,E֍jA Jxy}}@F]u)6^<^SSfWN/?pXCr'>E"ORd*< +¬4*DeRT*JA)Ai/7r=-9se9`DL|=Wzv1jQ\y#%1ElU[Qy?!`-8Fy($!9ݒ$--O~rK XV+ eu5ڤ|q;̊]9謖 +fԣ:̕rjks%hi>֮x):_sܴ`t R:/KJ(]:-t).eښnF`&4fӸ(7q+޻&kФ_f4_C2+_j0EvmGva&oJ+yT{jˮ=rm^W65][V״Xnnl%fӹ?~ib:t\}\,zC> +endobj + +21 0 obj +<< /Length 323 + /Filter /FlateDecode >> +stream +x]n0EH"v$BJH"CR1q}an@s3CRҚ7߫ +kƑL/._Cmϲ,K'7^7EEG͹o(ϙv|KKо,0a\N?t n0Z(> +endobj + +23 0 obj +<< /F1 12 0 R + /F2 17 0 R + /F3 22 0 R + >> +endobj + +24 0 obj +<< + /Font 23 0 R + /ProcSet [ /PDF ] +>> +endobj + +5 0 obj +<< /Type /Pages + /Resources 24 0 R + /MediaBox [ 0 0 595 842 ] + /Kids [ 6 0 R + 7 0 R + ] + /Count 2 +>> +endobj + +25 0 obj +<< /Type /Catalog + /Pages 5 0 R +>> +endobj + +26 0 obj +<< /Creator +/Producer +/CreationDate (D:20060210160640+01'00') +>> +endobj + +xref +0 27 +0000000000 65535 f +0000000017 00000 n +0000021484 00000 n +0000021512 00000 n +0000044495 00000 n +0000107861 00000 n +0000044523 00000 n +0000044630 00000 n +0000044737 00000 n +0000071982 00000 n +0000072008 00000 n +0000072257 00000 n +0000072827 00000 n +0000073307 00000 n +0000093718 00000 n +0000093745 00000 n +0000094000 00000 n +0000094455 00000 n +0000094818 00000 n +0000106749 00000 n +0000106776 00000 n +0000107021 00000 n +0000107427 00000 n +0000107722 00000 n +0000107794 00000 n +0000108016 00000 n +0000108076 00000 n +trailer +<< /Size 27 + /Root 25 0 R + /Info 26 0 R +>> +startxref +108283 +%%EOF diff --git a/Circular_kernel_2/benchmark/readme.sxw b/Circular_kernel_2/benchmark/readme.sxw new file mode 100644 index 00000000000..2d537f8ca97 Binary files /dev/null and b/Circular_kernel_2/benchmark/readme.sxw differ